account-financial-reporting/account_financial_report/tests/abstract_test.py

# Author: Julien Coux
# Copyright 2016 Camptocamp SA
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).

import logging

from odoo.tests import common
from odoo.tools import test_reports

_logger = logging.getLogger(__name__)


class AbstractTest(common.TransactionCase):
    """Common technical tests for all reports."""

    at_install = False
    post_install = True

    accounts = {}

    def with_context(self, *args, **kwargs):
        context = dict(args[0] if args else self.env.context, **kwargs)
        self.env = self.env(context=context)
        return self

    def _chart_template_create(self):
        transfer_account_id = self.env["account.account.template"].create(
            {
                "code": "000",
                "name": "Liquidity Transfers",
                "reconcile": True,
                "user_type_id": self.ref("account.data_account_type_current_assets"),
            }
        )
        self.chart = self.env["account.chart.template"].create(
            {
                "name": "Test COA",
                "code_digits": 4,
                "bank_account_code_prefix": 1014,
                "cash_account_code_prefix": 1014,
                "currency_id": self.ref("base.USD"),
                "transfer_account_code_prefix": "000",
            }
        )
        transfer_account_id.update(
            {"chart_template_id": self.chart.id,}
        )
        self.env["ir.model.data"].create(
            {
                "res_id": transfer_account_id.id,
                "model": transfer_account_id._name,
                "name": "Liquidity Transfers",
            }
        )
        act = self.env["account.account.template"].create(
            {
                "code": "001",
                "name": "Expenses",
                "user_type_id": self.ref("account.data_account_type_expenses"),
                "chart_template_id": self.chart.id,
                "reconcile": True,
            }
        )
        self.env["ir.model.data"].create(
            {"res_id": act.id, "model": act._name, "name": "expenses",}
        )
        act = self.env["account.account.template"].create(
            {
                "code": "002",
                "name": "Product Sales",
                "user_type_id": self.ref("account.data_account_type_revenue"),
                "chart_template_id": self.chart.id,
                "reconcile": True,
            }
        )
        self.env["ir.model.data"].create(
            {"res_id": act.id, "model": act._name, "name": "sales",}
        )
        act = self.env["account.account.template"].create(
            {
                "code": "003",
                "name": "Account Receivable",
                "user_type_id": self.ref("account.data_account_type_receivable"),
                "chart_template_id": self.chart.id,
                "reconcile": True,
            }
        )
        self.env["ir.model.data"].create(
            {"res_id": act.id, "model": act._name, "name": "receivable",}
        )
        act = self.env["account.account.template"].create(
            {
                "code": "004",
                "name": "Account Payable",
                "user_type_id": self.ref("account.data_account_type_payable"),
                "chart_template_id": self.chart.id,
                "reconcile": True,
            }
        )
        self.env["ir.model.data"].create(
            {"res_id": act.id, "model": act._name, "name": "payable",}
        )

    def _add_chart_of_accounts(self):
        self.company = self.env["res.company"].create({"name": "Spanish test company",})
        self.env.ref("base.group_multi_company").write(
            {"users": [(4, self.env.uid)],}
        )
        self.env.user.write(
            {"company_ids": [(4, self.company.id)], "company_id": self.company.id,}
        )
        self.with_context(company_id=self.company.id, force_company=self.company.id)
        self.chart.try_loading_for_current_company()
        self.revenue = self.env["account.account"].search(
            [("user_type_id", "=", self.ref("account.data_account_type_revenue"))],
            limit=1,
        )
        self.expense = self.env["account.account"].search(
            [("user_type_id", "=", self.ref("account.data_account_type_expenses"))],
            limit=1,
        )
        self.receivable = self.env["account.account"].search(
            [("user_type_id", "=", self.ref("account.data_account_type_receivable"))],
            limit=1,
        )
        self.payable = self.env["account.account"].search(
            [("user_type_id", "=", self.ref("account.data_account_type_payable"))],
            limit=1,
        )
        return True

    def _journals_create(self):
        self.journal_sale = self.env["account.journal"].create(
            {
                "company_id": self.company.id,
                "name": "Test journal for sale",
                "type": "sale",
                "code": "TSALE",
                "default_debit_account_id": self.revenue.id,
                "default_credit_account_id": self.revenue.id,
            }
        )
        self.journal_purchase = self.env["account.journal"].create(
            {
                "company_id": self.company.id,
                "name": "Test journal for purchase",
                "type": "purchase",
                "code": "TPUR",
                "default_debit_account_id": self.expense.id,
                "default_credit_account_id": self.expense.id,
            }
        )
        return True

    def _invoice_create(self):
        self.partner = self.env["res.partner"].create(
            {
                "name": "Test partner",
                "company_id": self.company.id,
                "property_account_receivable_id": self.receivable.id,
                "property_account_payable_id": self.payable.id,
            }
        )

        # customer invoice
        customer_invoice_lines = [
            (
                0,
                False,
                {
                    "name": "Test description #1",
                    "account_id": self.revenue.id,
                    "quantity": 1.0,
                    "price_unit": 100.0,
                },
            ),
            (
                0,
                False,
                {
                    "name": "Test description #2",
                    "account_id": self.revenue.id,
                    "quantity": 2.0,
                    "price_unit": 25.0,
                },
            ),
        ]
        self.invoice_out = self.env["account.invoice"].create(
            {
                "partner_id": self.partner.id,
                "type": "out_invoice",
                "invoice_line_ids": customer_invoice_lines,
                "account_id": self.partner.property_account_receivable_id.id,
                "journal_id": self.journal_sale.id,
            }
        )
        self.invoice_out.action_invoice_open()

        # vendor bill
        vendor_invoice_lines = [
            (
                0,
                False,
                {
                    "name": "Test description #1",
                    "account_id": self.revenue.id,
                    "quantity": 1.0,
                    "price_unit": 100.0,
                },
            ),
            (
                0,
                False,
                {
                    "name": "Test description #2",
                    "account_id": self.revenue.id,
                    "quantity": 2.0,
                    "price_unit": 25.0,
                },
            ),
        ]
        self.invoice_in = self.env["account.invoice"].create(
            {
                "partner_id": self.partner.id,
                "type": "in_invoice",
                "invoice_line_ids": vendor_invoice_lines,
                "account_id": self.partner.property_account_payable_id.id,
                "journal_id": self.journal_purchase.id,
            }
        )
        self.invoice_in.action_invoice_open()

    def setUp(self):
        super(AbstractTest, self).setUp()

        self.with_context()
        self._chart_template_create()
        self._add_chart_of_accounts()
        self._journals_create()
        self._invoice_create()

        self.model = self._getReportModel()

        self.qweb_report_name = self._getQwebReportName()
        self.xlsx_report_name = self._getXlsxReportName()
        self.xlsx_action_name = self._getXlsxReportActionName()

        self.report_title = self._getReportTitle()

        self.base_filters = self._getBaseFilters()
        self.additional_filters = self._getAdditionalFiltersToBeTested()

        self.report = self.model.create(self.base_filters)
        self.report.compute_data_for_report()

    def test_html(self):
        test_reports.try_report(
            self.env.cr,
            self.env.uid,
            self.qweb_report_name,
            [self.report.id],
            report_type="qweb-html",
        )

    def test_qweb(self):
        test_reports.try_report(
            self.env.cr,
            self.env.uid,
            self.qweb_report_name,
            [self.report.id],
            report_type="qweb-pdf",
        )

    def test_xlsx(self):
        test_reports.try_report(
            self.env.cr,
            self.env.uid,
            self.xlsx_report_name,
            [self.report.id],
            report_type="xlsx",
        )

    def test_print(self):
        self.report.print_report("qweb")
        self.report.print_report("xlsx")

    def test_02_generation_report_html(self):
        """Check if report HTML is correctly generated"""

        # Check if returned report action is correct
        report_type = "qweb-html"
        report_action = self.report.print_report(report_type)
        self.assertDictContainsSubset(
            {
                "type": "ir.actions.report",
                "report_name": self.qweb_report_name,
                "report_type": "qweb-html",
            },
            report_action,
        )

        # Check if report template is correct
        report = self.env["ir.actions.report"].search(
            [
                ("report_name", "=", self.qweb_report_name),
                ("report_type", "=", report_type),
            ],
            limit=1,
        )
        self.assertEqual(report.report_type, "qweb-html")

        rep = report.render(self.report.ids, {})

        self.assertTrue(self.report_title.encode("utf8") in rep[0])
        self.assertTrue(self.report.account_ids[0].name.encode("utf8") in rep[0])

    def test_04_compute_data(self):
        """Check that the SQL queries work with all filters options"""

        for filters in [{}] + self.additional_filters:
            current_filter = self.base_filters.copy()
            current_filter.update(filters)

            report = self.model.create(current_filter)
            report.compute_data_for_report()

            self.assertGreaterEqual(len(report.account_ids), 1)

            # Same filters with only one account
            current_filter = self.base_filters.copy()
            current_filter.update(filters)
            report_accounts = report.account_ids.filtered("account_id")
            current_filter.update(
                {"filter_account_ids": [(6, 0, report_accounts[0].account_id.ids)],}
            )

            report2 = self.model.create(current_filter)
            report2.compute_data_for_report()

            self.assertEqual(len(report2.account_ids), 1)
            self.assertEqual(report2.account_ids.name, report_accounts[0].name)

            if self._partner_test_is_possible(filters):
                # Same filters with only one partner
                report_partner_ids = report.account_ids.mapped("partner_ids")
                partner_ids = report_partner_ids.mapped("partner_id")

                current_filter = self.base_filters.copy()
                current_filter.update(filters)
                current_filter.update(
                    {"filter_partner_ids": [(6, 0, partner_ids[0].ids)],}
                )

                report3 = self.model.create(current_filter)
                report3.compute_data_for_report()

                self.assertGreaterEqual(len(report3.account_ids), 1)

                report_partner_ids3 = report3.account_ids.mapped("partner_ids")
                partner_ids3 = report_partner_ids3.mapped("partner_id")

                self.assertEqual(len(partner_ids3), 1)
                self.assertEqual(partner_ids3.name, partner_ids[0].name)

                # Same filters with only one partner and one account
                report_partner_ids = report3.account_ids.mapped("partner_ids")
                report_account_id = report_partner_ids.filtered(lambda p: p.partner_id)[
                    0
                ].report_account_id

                current_filter = self.base_filters.copy()
                current_filter.update(filters)
                current_filter.update(
                    {
                        "filter_account_ids": [
                            (6, 0, report_account_id.account_id.ids)
                        ],
                        "filter_partner_ids": [(6, 0, partner_ids[0].ids)],
                    }
                )

                report4 = self.model.create(current_filter)
                report4.compute_data_for_report()

                self.assertEqual(len(report4.account_ids), 1)
                self.assertEqual(
                    report4.account_ids.name, report_account_id.account_id.name
                )

                report_partner_ids4 = report4.account_ids.mapped("partner_ids")
                partner_ids4 = report_partner_ids4.mapped("partner_id")

                self.assertEqual(len(partner_ids4), 1)
                self.assertEqual(partner_ids4.name, partner_ids[0].name)

    def _partner_test_is_possible(self, filters):
        """
            :return:
                a boolean to indicate if partner test is possible
                with current filters
        """
        return True

    def _getReportModel(self):
        """
            :return: the report model name
        """
        raise NotImplementedError()

    def _getQwebReportName(self):
        """
            :return: the qweb report name
        """
        raise NotImplementedError()

    def _getXlsxReportName(self):
        """
            :return: the xlsx report name
        """
        raise NotImplementedError()

    def _getXlsxReportActionName(self):
        """
            :return: the xlsx report action name
        """
        raise NotImplementedError()

    def _getReportTitle(self):
        """
            :return: the report title displayed into the report
        """
        raise NotImplementedError()

    def _getBaseFilters(self):
        """
            :return: the minimum required filters to generate report
        """
        raise NotImplementedError()

    def _getAdditionalFiltersToBeTested(self):
        """
            :return: the additional filters to generate report variants
        """
        raise NotImplementedError()