initial commit 2

5 files changed, 741 insertions, 0 deletions

diff --git a/addons/purchase/tests/__init__.py b/addons/purchase/tests/__init__.py
new file mode 100644
index 00000000..b97052ae
--- /dev/null
+++ b/addons/purchase/tests/__init__.py
@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import test_purchase
+from . import test_purchase_order_report
+from . import test_purchase_invoice
+from . import test_access_rights
diff --git a/addons/purchase/tests/test_access_rights.py b/addons/purchase/tests/test_access_rights.py
new file mode 100644
index 00000000..855b0270
--- /dev/null
+++ b/addons/purchase/tests/test_access_rights.py
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+from odoo.addons.account.tests.common import AccountTestInvoicingCommon
+from odoo.tests import Form, tagged
+from odoo.exceptions import AccessError
+
+
+@tagged('post_install', '-at_install')
+class TestPurchaseInvoice(AccountTestInvoicingCommon):
+
+    @classmethod
+    def setUpClass(cls, chart_template_ref=None):
+        super().setUpClass(chart_template_ref=chart_template_ref)
+
+        # Create a users
+        group_purchase_user = cls.env.ref('purchase.group_purchase_user')
+        group_employee = cls.env.ref('base.group_user')
+        group_partner_manager = cls.env.ref('base.group_partner_manager')
+
+        cls.purchase_user = cls.env['res.users'].with_context(
+            no_reset_password=True
+        ).create({
+            'name': 'Purchase user',
+            'login': 'purchaseUser',
+            'email': 'pu@odoo.com',
+            'groups_id': [(6, 0, [group_purchase_user.id, group_employee.id, group_partner_manager.id])],
+        })
+
+        cls.vendor = cls.env['res.partner'].create({
+            'name': 'Supplier',
+            'email': 'supplier.serv@supercompany.com',
+        })
+
+        user_type_expense = cls.env.ref('account.data_account_type_expenses')
+        cls.account_expense_product = cls.env['account.account'].create({
+            'code': 'EXPENSE_PROD111',
+            'name': 'Expense - Test Account',
+            'user_type_id': user_type_expense.id,
+        })
+        # Create category
+        cls.product_category = cls.env['product.category'].create({
+            'name': 'Product Category with Expense account',
+            'property_account_expense_categ_id': cls.account_expense_product.id
+        })
+        cls.product = cls.env['product.product'].create({
+            'name': "Product",
+            'standard_price': 200.0,
+            'list_price': 180.0,
+            'type': 'service',
+        })
+
+    def test_create_purchase_order(self):
+        """Check a purchase user can create a vendor bill from a purchase order but not post it"""
+        purchase_order_form = Form(self.env['purchase.order'].with_user(self.purchase_user))
+        purchase_order_form.partner_id = self.vendor
+        with purchase_order_form.order_line.new() as line:
+            line.name = self.product.name
+            line.product_id = self.product
+            line.product_qty = 4
+            line.price_unit = 5
+
+        purchase_order = purchase_order_form.save()
+        purchase_order.button_confirm()
+
+        purchase_order.order_line.qty_received = 4
+        purchase_order.action_create_invoice()
+        invoice = purchase_order.invoice_ids
+        with self.assertRaises(AccessError):
+            invoice.action_post()
+
+    def test_read_purchase_order(self):
+        """ Check that a purchase user can read all purchase order and 'in' invoices"""
+        purchase_user_2 = self.purchase_user.copy({
+            'name': 'Purchase user 2',
+            'login': 'purchaseUser2',
+            'email': 'pu2@odoo.com',
+        })
+
+        purchase_order_form = Form(self.env['purchase.order'].with_user(purchase_user_2))
+        purchase_order_form.partner_id = self.vendor
+        with purchase_order_form.order_line.new() as line:
+            line.name = self.product.name
+            line.product_id = self.product
+            line.product_qty = 4
+            line.price_unit = 5
+
+        purchase_order_user2 = purchase_order_form.save()
+        purchase_order_user2.button_confirm()
+
+        purchase_order_user2.order_line.qty_received = 4
+        purchase_order_user2.action_create_invoice()
+        vendor_bill_user2 = purchase_order_user2.invoice_ids
+
+        # open purchase_order_user2 and vendor_bill_user2 with `self.purchase_user`
+        purchase_order_user1 = Form(purchase_order_user2.with_user(self.purchase_user))
+        purchase_order_user1 = purchase_order_user1.save()
+        vendor_bill_user1 = Form(vendor_bill_user2.with_user(self.purchase_user))
+        vendor_bill_user1 = vendor_bill_user1.save()
+
+    def test_read_purchase_order_2(self):
+        """ Check that a 2 purchase users with open the vendor bill the same
+        way even with a 'own documents only' record rule. """
+
+        # edit the account.move record rule for purchase user in order to ensure
+        # a user can only see his own invoices
+        rule = self.env.ref('purchase.purchase_user_account_move_rule')
+        rule.domain_force = "['&', ('move_type', 'in', ('in_invoice', 'in_refund', 'in_receipt')), ('invoice_user_id', '=', user.id)]"
+
+        # create a purchase and make a vendor bill from it as purchase user 2
+        purchase_user_2 = self.purchase_user.copy({
+            'name': 'Purchase user 2',
+            'login': 'purchaseUser2',
+            'email': 'pu2@odoo.com',
+        })
+
+        purchase_order_form = Form(self.env['purchase.order'].with_user(purchase_user_2))
+        purchase_order_form.partner_id = self.vendor
+        with purchase_order_form.order_line.new() as line:
+            line.name = self.product.name
+            line.product_id = self.product
+            line.product_qty = 4
+            line.price_unit = 5
+
+        purchase_order_user2 = purchase_order_form.save()
+        purchase_order_user2.button_confirm()
+
+        purchase_order_user2.order_line.qty_received = 4
+        purchase_order_user2.action_create_invoice()
+        vendor_bill_user2 = purchase_order_user2.invoice_ids
+
+        # check user 1 cannot read the invoice
+        with self.assertRaises(AccessError):
+            Form(vendor_bill_user2.with_user(self.purchase_user))
+
+        # Check that calling 'action_view_invoice' return the same action despite the record rule
+        action_user_1 = purchase_order_user2.with_user(self.purchase_user).action_view_invoice()
+        purchase_order_user2.invalidate_cache()
+        action_user_2 = purchase_order_user2.with_user(purchase_user_2).action_view_invoice()
+        self.assertEqual(action_user_1, action_user_2)
+
+    def test_double_validation(self):
+        """Only purchase managers can approve a purchase order when double
+        validation is enabled"""
+        group_purchase_manager = self.env.ref('purchase.group_purchase_manager')
+        order = self.env.ref("purchase.purchase_order_1")
+        company = order.sudo().company_id
+        company.po_double_validation = 'two_step'
+        company.po_double_validation_amount = 0
+        self.purchase_user.write({
+            'company_ids': [(4, company.id)],
+            'company_id': company.id,
+            'groups_id': [(3, group_purchase_manager.id)],
+        })
+        order.with_user(self.purchase_user).button_confirm()
+        self.assertEqual(order.state, 'to approve')
+        order.with_user(self.purchase_user).button_approve()
+        self.assertEqual(order.state, 'to approve')
+        self.purchase_user.groups_id += group_purchase_manager
+        order.with_user(self.purchase_user).button_approve()
+        self.assertEqual(order.state, 'purchase')
diff --git a/addons/purchase/tests/test_purchase.py b/addons/purchase/tests/test_purchase.py
new file mode 100644
index 00000000..8571f351
--- /dev/null
+++ b/addons/purchase/tests/test_purchase.py
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+from odoo.addons.account.tests.common import AccountTestInvoicingCommon
+from odoo.tests import tagged, Form
+from odoo import fields
+
+
+from datetime import timedelta
+
+
+@tagged('-at_install', 'post_install')
+class TestPurchase(AccountTestInvoicingCommon):
+
+    def test_date_planned(self):
+        """Set a date planned on 2 PO lines. Check that the PO date_planned is the earliest PO line date
+        planned. Change one of the dates so it is even earlier and check that the date_planned is set to
+        this earlier date.
+        """
+        po = Form(self.env['purchase.order'])
+        po.partner_id = self.partner_a
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_a
+            po_line.product_qty = 1
+            po_line.price_unit = 100
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_b
+            po_line.product_qty = 10
+            po_line.price_unit = 200
+        po = po.save()
+
+        # Check that the same date is planned on both PO lines.
+        self.assertNotEqual(po.order_line[0].date_planned, False)
+        self.assertAlmostEqual(po.order_line[0].date_planned, po.order_line[1].date_planned, delta=timedelta(seconds=10))
+        self.assertAlmostEqual(po.order_line[0].date_planned, po.date_planned, delta=timedelta(seconds=10))
+
+        orig_date_planned = po.order_line[0].date_planned
+
+        # Set an earlier date planned on a PO line and check that the PO expected date matches it.
+        new_date_planned = orig_date_planned - timedelta(hours=1)
+        po.order_line[0].date_planned = new_date_planned
+        self.assertAlmostEqual(po.order_line[0].date_planned, po.date_planned, delta=timedelta(seconds=10))
+
+        # Set an even earlier date planned on the other PO line and check that the PO expected date matches it.
+        new_date_planned = orig_date_planned - timedelta(hours=72)
+        po.order_line[1].date_planned = new_date_planned
+        self.assertAlmostEqual(po.order_line[1].date_planned, po.date_planned, delta=timedelta(seconds=10))
+
+    def test_purchase_order_sequence(self):
+        PurchaseOrder = self.env['purchase.order'].with_context(tracking_disable=True)
+        company = self.env.user.company_id
+        self.env['ir.sequence'].search([
+            ('code', '=', 'purchase.order'),
+        ]).write({
+            'use_date_range': True, 'prefix': 'PO/%(range_year)s/',
+        })
+        vals = {
+            'partner_id': self.partner_a.id,
+            'company_id': company.id,
+            'currency_id': company.currency_id.id,
+            'date_order': '2019-01-01',
+        }
+        purchase_order = PurchaseOrder.create(vals.copy())
+        self.assertTrue(purchase_order.name.startswith('PO/2019/'))
+        vals['date_order'] = '2020-01-01'
+        purchase_order = PurchaseOrder.create(vals.copy())
+        self.assertTrue(purchase_order.name.startswith('PO/2020/'))
+        # In EU/BXL tz, this is actually already 01/01/2020
+        vals['date_order'] = '2019-12-31 23:30:00'
+        purchase_order = PurchaseOrder.with_context(tz='Europe/Brussels').create(vals.copy())
+        self.assertTrue(purchase_order.name.startswith('PO/2020/'))
+
+    def test_reminder_1(self):
+        """Set to send reminder today, check if a reminder can be send to the
+        partner.
+        """
+        po = Form(self.env['purchase.order'])
+        po.partner_id = self.partner_a
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_a
+            po_line.product_qty = 1
+            po_line.price_unit = 100
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_b
+            po_line.product_qty = 10
+            po_line.price_unit = 200
+        # set to send reminder today
+        po.date_planned = fields.Datetime.now() + timedelta(days=1)
+        po.receipt_reminder_email = True
+        po.reminder_date_before_receipt = 1
+        po = po.save()
+        po.button_confirm()
+
+        # check vendor is a message recipient
+        self.assertTrue(po.partner_id in po.message_partner_ids)
+
+        old_messages = po.message_ids
+        po._send_reminder_mail()
+        messages_send = po.message_ids - old_messages
+        # check reminder send
+        self.assertTrue(messages_send)
+        self.assertTrue(po.partner_id in messages_send.mapped('partner_ids'))
+
+        # check confirm button
+        po.confirm_reminder_mail()
+        self.assertTrue(po.mail_reminder_confirmed)
+
+    def test_reminder_2(self):
+        """Set to send reminder tomorrow, check if no reminder can be send.
+        """
+        po = Form(self.env['purchase.order'])
+        po.partner_id = self.partner_a
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_a
+            po_line.product_qty = 1
+            po_line.price_unit = 100
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_b
+            po_line.product_qty = 10
+            po_line.price_unit = 200
+        # set to send reminder tomorrow
+        po.date_planned = fields.Datetime.now() + timedelta(days=2)
+        po.receipt_reminder_email = True
+        po.reminder_date_before_receipt = 1
+        po = po.save()
+        po.button_confirm()
+
+        # check vendor is a message recipient
+        self.assertTrue(po.partner_id in po.message_partner_ids)
+
+        old_messages = po.message_ids
+        po._send_reminder_mail()
+        messages_send = po.message_ids - old_messages
+        # check no reminder send
+        self.assertFalse(messages_send)
+
+    def test_update_date_planned(self):
+        po = Form(self.env['purchase.order'])
+        po.partner_id = self.partner_a
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_a
+            po_line.product_qty = 1
+            po_line.price_unit = 100
+            po_line.date_planned = '2020-06-06 00:00:00'
+        with po.order_line.new() as po_line:
+            po_line.product_id = self.product_b
+            po_line.product_qty = 10
+            po_line.price_unit = 200
+            po_line.date_planned = '2020-06-06 00:00:00'
+        po = po.save()
+        po.button_confirm()
+
+        # update first line
+        po._update_date_planned_for_lines([(po.order_line[0], fields.Datetime.today())])
+        self.assertEqual(po.order_line[0].date_planned, fields.Datetime.today())
+        activity = self.env['mail.activity'].search([
+            ('summary', '=', 'Date Updated'),
+            ('res_model_id', '=', 'purchase.order'),
+            ('res_id', '=', po.id),
+        ])
+        self.assertTrue(activity)
+        self.assertIn(
+            '<p> partner_a modified receipt dates for the following products:</p><p> \xa0 - product_a from 2020-06-06 to %s </p>' % fields.Date.today(),
+            activity.note,
+        )
+
+        # update second line
+        po._update_date_planned_for_lines([(po.order_line[1], fields.Datetime.today())])
+        self.assertEqual(po.order_line[1].date_planned, fields.Datetime.today())
+        self.assertIn(
+            '<p> partner_a modified receipt dates for the following products:</p><p> \xa0 - product_a from 2020-06-06 to %s </p><p> \xa0 - product_b from 2020-06-06 to %s </p>' % (fields.Date.today(), fields.Date.today()),
+            activity.note,
+        )
+
+    def test_with_different_uom(self):
+        """ This test ensures that the unit price is correctly computed"""
+        uom_units = self.env['ir.model.data'].xmlid_to_object('uom.product_uom_unit')
+        uom_dozens = self.env['ir.model.data'].xmlid_to_object('uom.product_uom_dozen')
+        uom_pairs = self.env['uom.uom'].create({
+            'name': 'Pairs',
+            'category_id': uom_units.category_id.id,
+            'uom_type': 'bigger',
+            'factor_inv': 2,
+            'rounding': 1,
+        })
+        product_data = {
+            'name': 'SuperProduct',
+            'type': 'consu',
+            'uom_id': uom_units.id,
+            'uom_po_id': uom_pairs.id,
+            'standard_price': 100
+        }
+        product_01 = self.env['product.product'].create(product_data)
+        product_02 = self.env['product.product'].create(product_data)
+
+        po_form = Form(self.env['purchase.order'])
+        po_form.partner_id = self.partner_a
+        with po_form.order_line.new() as po_line:
+            po_line.product_id = product_01
+        with po_form.order_line.new() as po_line:
+            po_line.product_id = product_02
+            po_line.product_uom = uom_dozens
+        po = po_form.save()
+
+        self.assertEqual(po.order_line[0].price_unit, 200)
+        self.assertEqual(po.order_line[1].price_unit, 1200)
diff --git a/addons/purchase/tests/test_purchase_invoice.py b/addons/purchase/tests/test_purchase_invoice.py
new file mode 100644
index 00000000..3c67d2eb
--- /dev/null
+++ b/addons/purchase/tests/test_purchase_invoice.py
@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+from odoo.addons.account.tests.common import AccountTestInvoicingCommon
+from odoo.tests import tagged
+from odoo.tests.common import Form
+
+
+@tagged('post_install', '-at_install')
+class TestPurchaseToInvoice(AccountTestInvoicingCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestPurchaseToInvoice, cls).setUpClass()
+        uom_unit = cls.env.ref('uom.product_uom_unit')
+        uom_hour = cls.env.ref('uom.product_uom_hour')
+        cls.product_order = cls.env['product.product'].create({
+            'name': "Zed+ Antivirus",
+            'standard_price': 235.0,
+            'list_price': 280.0,
+            'type': 'consu',
+            'uom_id': uom_unit.id,
+            'uom_po_id': uom_unit.id,
+            'purchase_method': 'purchase',
+            'default_code': 'PROD_ORDER',
+            'taxes_id': False,
+        })
+        cls.service_deliver = cls.env['product.product'].create({
+            'name': "Cost-plus Contract",
+            'standard_price': 200.0,
+            'list_price': 180.0,
+            'type': 'service',
+            'uom_id': uom_unit.id,
+            'uom_po_id': uom_unit.id,
+            'purchase_method': 'receive',
+            'default_code': 'SERV_DEL',
+            'taxes_id': False,
+        })
+        cls.service_order = cls.env['product.product'].create({
+            'name': "Prepaid Consulting",
+            'standard_price': 40.0,
+            'list_price': 90.0,
+            'type': 'service',
+            'uom_id': uom_hour.id,
+            'uom_po_id': uom_hour.id,
+            'purchase_method': 'purchase',
+            'default_code': 'PRE-PAID',
+            'taxes_id': False,
+        })
+        cls.product_deliver = cls.env['product.product'].create({
+            'name': "Switch, 24 ports",
+            'standard_price': 55.0,
+            'list_price': 70.0,
+            'type': 'consu',
+            'uom_id': uom_unit.id,
+            'uom_po_id': uom_unit.id,
+            'purchase_method': 'receive',
+            'default_code': 'PROD_DEL',
+            'taxes_id': False,
+        })
+
+    def test_vendor_bill_delivered(self):
+        """Test if a order of product invoiced by delivered quantity can be
+        correctly invoiced."""
+        purchase_order = self.env['purchase.order'].with_context(tracking_disable=True).create({
+            'partner_id': self.partner_a.id,
+        })
+        PurchaseOrderLine = self.env['purchase.order.line'].with_context(tracking_disable=True)
+        pol_prod_deliver = PurchaseOrderLine.create({
+            'name': self.product_deliver.name,
+            'product_id': self.product_deliver.id,
+            'product_qty': 10.0,
+            'product_uom': self.product_deliver.uom_id.id,
+            'price_unit': self.product_deliver.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        pol_serv_deliver = PurchaseOrderLine.create({
+            'name': self.service_deliver.name,
+            'product_id': self.service_deliver.id,
+            'product_qty': 10.0,
+            'product_uom': self.service_deliver.uom_id.id,
+            'price_unit': self.service_deliver.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        purchase_order.button_confirm()
+
+        self.assertEqual(purchase_order.invoice_status, "no")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 0.0)
+
+        purchase_order.order_line.qty_received = 5
+        self.assertEqual(purchase_order.invoice_status, "to invoice")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 5)
+            self.assertEqual(line.qty_invoiced, 0.0)
+
+        purchase_order.action_create_invoice()
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 5)
+
+    def test_vendor_bill_ordered(self):
+        """Test if a order of product invoiced by ordered quantity can be
+        correctly invoiced."""
+        purchase_order = self.env['purchase.order'].with_context(tracking_disable=True).create({
+            'partner_id': self.partner_a.id,
+        })
+        PurchaseOrderLine = self.env['purchase.order.line'].with_context(tracking_disable=True)
+        pol_prod_order = PurchaseOrderLine.create({
+            'name': self.product_order.name,
+            'product_id': self.product_order.id,
+            'product_qty': 10.0,
+            'product_uom': self.product_order.uom_id.id,
+            'price_unit': self.product_order.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        pol_serv_order = PurchaseOrderLine.create({
+            'name': self.service_order.name,
+            'product_id': self.service_order.id,
+            'product_qty': 10.0,
+            'product_uom': self.service_order.uom_id.id,
+            'price_unit': self.service_order.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        purchase_order.button_confirm()
+
+        self.assertEqual(purchase_order.invoice_status, "to invoice")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 10)
+            self.assertEqual(line.qty_invoiced, 0.0)
+
+        purchase_order.order_line.qty_received = 5
+        self.assertEqual(purchase_order.invoice_status, "to invoice")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 10)
+            self.assertEqual(line.qty_invoiced, 0.0)
+
+        purchase_order.action_create_invoice()
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 10)
+
+    def test_vendor_bill_delivered_return(self):
+        """Test when return product, a order of product invoiced by delivered
+        quantity can be correctly invoiced."""
+        purchase_order = self.env['purchase.order'].with_context(tracking_disable=True).create({
+            'partner_id': self.partner_a.id,
+        })
+        PurchaseOrderLine = self.env['purchase.order.line'].with_context(tracking_disable=True)
+        pol_prod_deliver = PurchaseOrderLine.create({
+            'name': self.product_deliver.name,
+            'product_id': self.product_deliver.id,
+            'product_qty': 10.0,
+            'product_uom': self.product_deliver.uom_id.id,
+            'price_unit': self.product_deliver.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        pol_serv_deliver = PurchaseOrderLine.create({
+            'name': self.service_deliver.name,
+            'product_id': self.service_deliver.id,
+            'product_qty': 10.0,
+            'product_uom': self.service_deliver.uom_id.id,
+            'price_unit': self.service_deliver.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        purchase_order.button_confirm()
+
+        purchase_order.order_line.qty_received = 10
+        purchase_order.action_create_invoice()
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 10)
+
+        purchase_order.order_line.qty_received = 5
+        self.assertEqual(purchase_order.invoice_status, "to invoice")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, -5)
+            self.assertEqual(line.qty_invoiced, 10)
+        purchase_order.action_create_invoice()
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 5)
+
+    def test_vendor_bill_ordered_return(self):
+        """Test when return product, a order of product invoiced by ordered
+        quantity can be correctly invoiced."""
+        purchase_order = self.env['purchase.order'].with_context(tracking_disable=True).create({
+            'partner_id': self.partner_a.id,
+        })
+        PurchaseOrderLine = self.env['purchase.order.line'].with_context(tracking_disable=True)
+        pol_prod_order = PurchaseOrderLine.create({
+            'name': self.product_order.name,
+            'product_id': self.product_order.id,
+            'product_qty': 10.0,
+            'product_uom': self.product_order.uom_id.id,
+            'price_unit': self.product_order.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        pol_serv_order = PurchaseOrderLine.create({
+            'name': self.service_order.name,
+            'product_id': self.service_order.id,
+            'product_qty': 10.0,
+            'product_uom': self.service_order.uom_id.id,
+            'price_unit': self.service_order.list_price,
+            'order_id': purchase_order.id,
+            'taxes_id': False,
+        })
+        purchase_order.button_confirm()
+
+        purchase_order.order_line.qty_received = 10
+        purchase_order.action_create_invoice()
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 10)
+
+        purchase_order.order_line.qty_received = 5
+        self.assertEqual(purchase_order.invoice_status, "invoiced")
+        for line in purchase_order.order_line:
+            self.assertEqual(line.qty_to_invoice, 0.0)
+            self.assertEqual(line.qty_invoiced, 10)
+
+    def test_vendor_severals_bills_and_multicurrency(self):
+        """
+        This test ensures that, when adding several PO to a bill, if they are expressed with different
+        currency, the amount of each AML is converted to the bill's currency
+        """
+        PurchaseOrderLine = self.env['purchase.order.line']
+        PurchaseBillUnion = self.env['purchase.bill.union']
+        ResCurrencyRate = self.env['res.currency.rate']
+        usd = self.env.ref('base.USD')
+        eur = self.env.ref('base.EUR')
+        purchase_orders = []
+
+        ResCurrencyRate.create({'currency_id': usd.id, 'rate': 1})
+        ResCurrencyRate.create({'currency_id': eur.id, 'rate': 2})
+
+        for currency in [usd, eur]:
+            po = self.env['purchase.order'].with_context(tracking_disable=True).create({
+                'partner_id': self.partner_a.id,
+                'currency_id': currency.id,
+            })
+            pol_prod_order = PurchaseOrderLine.create({
+                'name': self.product_order.name,
+                'product_id': self.product_order.id,
+                'product_qty': 1,
+                'product_uom': self.product_order.uom_id.id,
+                'price_unit': 1000,
+                'order_id': po.id,
+                'taxes_id': False,
+            })
+            po.button_confirm()
+            pol_prod_order.write({'qty_received': 1})
+            purchase_orders.append(po)
+
+        move_form = Form(self.env['account.move'].with_context(default_move_type='in_invoice'))
+        move_form.purchase_vendor_bill_id = PurchaseBillUnion.browse(-purchase_orders[0].id)
+        move_form.purchase_vendor_bill_id = PurchaseBillUnion.browse(-purchase_orders[1].id)
+        move = move_form.save()
+        amls = move.line_ids.filtered(lambda l: l.account_internal_group == 'expense')
+
+        self.assertEqual(move.amount_total, 1500)
+        self.assertEqual(move.currency_id, usd)
+        self.assertEqual(len(amls), 2)
+        self.assertEqual(amls[0].amount_currency, 1000)
+        self.assertEqual(amls[1].amount_currency, 500)
+
+    def test_product_price_decimal_accuracy(self):
+        self.env['ir.model.data'].xmlid_to_object('product.decimal_price').digits = 3
+        self.env.company.currency_id.rounding = 0.01
+
+        po = self.env['purchase.order'].with_context(tracking_disable=True).create({
+            'partner_id': self.partner_a.id,
+            'order_line': [(0, 0, {
+                'name': self.product_a.name,
+                'product_id': self.product_a.id,
+                'product_qty': 12,
+                'product_uom': self.product_a.uom_id.id,
+                'price_unit': 0.001,
+                'taxes_id': False,
+            })]
+        })
+        po.button_confirm()
+        po.order_line.qty_received = 12
+
+        move_form = Form(self.env['account.move'].with_context(default_move_type='in_invoice'))
+        move_form.purchase_vendor_bill_id = self.env['purchase.bill.union'].browse(-po.id)
+        move = move_form.save()
+
+        self.assertEqual(move.amount_total, 0.01)
diff --git a/addons/purchase/tests/test_purchase_order_report.py b/addons/purchase/tests/test_purchase_order_report.py
new file mode 100644
index 00000000..8b386113
--- /dev/null
+++ b/addons/purchase/tests/test_purchase_order_report.py
@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+from odoo.addons.account.tests.common import AccountTestInvoicingCommon
+from odoo.tests import Form, tagged
+
+from datetime import datetime
+
+
+@tagged('post_install', '-at_install')
+class TestPurchaseOrderReport(AccountTestInvoicingCommon):
+
+    def test_00_purchase_order_report(self):
+        uom_dozen = self.env.ref('uom.product_uom_dozen')
+
+        po = self.env['purchase.order'].create({
+            'partner_id': self.partner_a.id,
+            'currency_id': self.currency_data['currency'].id,
+            'order_line': [
+                (0, 0, {
+                    'name': self.product_a.name,
+                    'product_id': self.product_a.id,
+                    'product_qty': 1.0,
+                    'product_uom': uom_dozen.id,
+                    'price_unit': 100.0,
+                    'date_planned': datetime.today(),
+                    'taxes_id': False,
+                }),
+                (0, 0, {
+                    'name': self.product_b.name,
+                    'product_id': self.product_b.id,
+                    'product_qty': 1.0,
+                    'product_uom': uom_dozen.id,
+                    'price_unit': 200.0,
+                    'date_planned': datetime.today(),
+                    'taxes_id': False,
+                }),
+            ],
+        })
+        po.button_confirm()
+
+        f = Form(self.env['account.move'].with_context(default_move_type='in_invoice'))
+        f.invoice_date = f.date
+        f.partner_id = po.partner_id
+        f.purchase_id = po
+        invoice = f.save()
+        invoice.action_post()
+        po.flush()
+
+        res_product1 = self.env['purchase.report'].search([
+            ('order_id', '=', po.id),
+            ('product_id', '=', self.product_a.id),
+            ('company_id', '=', self.company_data['company'].id),
+        ])
+
+        # check that report will convert dozen to unit or not
+        self.assertEqual(res_product1.qty_ordered, 12.0, 'UoM conversion is not working')
+        # report should show in company currency (amount/rate) = (100/2)
+        self.assertEqual(res_product1.price_total, 50.0, 'Currency conversion is not working')
+
+        res_product2 = self.env['purchase.report'].search([
+            ('order_id', '=', po.id),
+            ('product_id', '=', self.product_b.id),
+            ('company_id', '=', self.company_data['company'].id),
+        ])
+
+        self.assertEqual(res_product2.qty_ordered, 1.0, 'No conversion needed since product_b is already a dozen')
+        # report should show in company currency (amount/rate) = (200/2)
+        self.assertEqual(res_product2.price_total, 100.0, 'Currency conversion is not working')