[FIX] stock_currency_valuation: resolve the valuation currency per record company

Contract of the seam ``account-multicompany-ux`` <-> ``stock-currency-valuation``:
the valuation currency lives on the product CATEGORY and is company-dependent, so
reading it off the ambient company answers for the wrong one as soon as the record
belongs to another — routine with multi-company UX, where a user can have company A
selected and operate on a record of company B.

``stock.quant._compute_secondary_value`` read the guard off the ambient company and
the price with ``with_company(quant.company_id)``. When the active company has no
valuation currency and the quant's does, the guard answers "none" —true for the
active one— and the quant is skipped: its secondary value is not wrong, it is
missing. The product is now resolved once with the quant's company and reused for
both. ``stock.move._set_value`` had the same read on its conversion branch.

The three violations this was expected to fix in ``product.product`` do not exist,
and were checked one by one before touching anything: that model has no company of
its own, so for its company-dependent fields the CONTEXT company is the semantic
one. ``_get_last_product_value`` filters by ``self.env.company`` exactly as the core
does, and ``write`` / ``_change_standard_price`` read in the very company they are
writing to. ``stock.picking`` and ``stock.landed.cost`` already comply.

Left out on purpose: ``valuation_currency_id`` is a ``related`` on ``stock.move``,
``stock.quant`` and the AVCO report, and a ``related`` always resolves in the ambient
company with no way to apply ``with_company``, so two companies valuing the same
category in different currencies can see a right amount under the wrong symbol. The
fix is a compute with the record's company, which has consequences for views and
searches.

Verified in both directions: with the fix the suite is green, and without it the
test fails 0.0 != 3500.0. The test uses a category whose valuation currency exists
ONLY in company B and re-browses the quant from an env with company A — reading it
on the ``with_company(company_b)`` recordset that created it proves nothing, since a
company-dependent field resolves off the RECORDSET's context.

Part-of: #1004
Related: ingadhoc/account-financial-tools#984
Related: ingadhoc/product#937
Related: ingadhoc/miscellaneous#436
Signed-off-by: Camila Vives <cav@adhoc.inc>

Author: maq-adhoc

stock_currency_valuation/models/stock_move.py

@@ -102,9 +102,14 @@ def _set_value(self, correction_quantity=None):
                     base_value_in_currency = base_value * move.picking_id.currency_rate
                     move.value_in_currency = base_value_in_currency + lc_value_in_currency
                 else:
-                    base_value_in_currency = move.with_company(move.company_id).company_id.currency_id._convert(
+                    # ``valuation_currency_id`` comes from the product category and is
+                    # company-dependent: resolved off the move's own company, not the
+                    # ambient one, which can be another company entirely under
+                    # account_multicompany_ux.
+                    move_in_company = move.with_company(move.company_id)
+                    base_value_in_currency = move_in_company.company_id.currency_id._convert(
                         from_amount=base_value,
-                        to_currency=move.valuation_currency_id,
+                        to_currency=move_in_company.valuation_currency_id,
                         company=move.company_id,
                         date=move.date,
                     )

stock_currency_valuation/models/stock_quant.py

@@ -25,13 +25,20 @@ class StockQuant(models.Model):
     def _compute_secondary_value(self):
         self.secondary_value = 0.0
         for quant in self:
-            if not quant.valuation_currency_id:
+            # The product is resolved ONCE with the quant's own company and reused for
+            # both the guard and the price. The valuation currency lives on the product
+            # category and is company-dependent, so reading it off the ambient company
+            # —as ``quant.valuation_currency_id`` does— can disagree with the price read
+            # below: with account_multicompany_ux a user can have company A selected
+            # while looking at a quant of company B, and then the guard answered for A
+            # and the amount for B.
+            product = quant.product_id.with_company(quant.company_id)
+            if not product.valuation_currency_id:
                 continue
             if not quant.location_id or not quant.product_id:
                 continue
             if not quant.location_id._should_be_valued() or quant._should_exclude_for_valuation():
                 continue
             if quant.product_id.uom_id.is_zero(quant.quantity):
                 continue
-            secondary_price = quant.product_id.with_company(quant.company_id).standard_price_in_currency
-            quant.secondary_value = quant.quantity * secondary_price
+            quant.secondary_value = quant.quantity * product.standard_price_in_currency

stock_currency_valuation/tests/__init__.py

@@ -5,3 +5,4 @@
 from . import test_delivery_and_return
 from . import test_replenishment_cost_average_in_currency
 from . import test_avco_report_uom
+from . import test_multicompany_currency

stock_currency_valuation/tests/test_multicompany_currency.py

@@ -0,0 +1,110 @@
+from odoo import Command
+from odoo.tests import tagged
+
+from .common import TestStockCurrencyValuationCommon
+
+
+@tagged("post_install", "-at_install")
+class TestMultiCompanyCurrency(TestStockCurrencyValuationCommon):
+    """The valuation currency lives on the product CATEGORY and is company-dependent, so
+    every backend read has to resolve it with the company of the RECORD and not with the
+    active one.
+
+    Contract of the seam ``account-multicompany-ux`` <-> ``stock-currency-valuation``:
+    with multi-company UX a user can have company A selected while operating on a record
+    of company B, and a company-dependent field read off the context then answers for the
+    wrong company — silently, returning a number instead of failing.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.company_b = cls.env["res.company"].create({"name": "SCV Company B"})
+        cls.env.user.company_ids = [Command.link(cls.company_b.id)]
+        cls.currency_b = cls.env["res.currency"].create(
+            {"name": "SCB", "symbol": "B$", "rounding": 0.01}
+        )
+        cls.env["res.currency.rate"].create(
+            {
+                "name": cls.DAY_1,
+                "rate": cls.RATE_D1,
+                "currency_id": cls.currency_b.id,
+                "company_id": cls.company_b.id,
+            }
+        )
+        # SAME category, a different valuation currency in each company.
+        cls.category.with_company(cls.company_b).valuation_currency_id = cls.currency_b
+        # And a different secondary cost in each one, so a crossed read is visible.
+        cls.product.with_company(cls.company).standard_price_in_currency = 100.0
+        cls.product.with_company(cls.company_b).standard_price_in_currency = 700.0
+        cls.warehouse_b = cls.env["stock.warehouse"].search(
+            [("company_id", "=", cls.company_b.id)], limit=1
+        )
+        # Category whose valuation currency exists ONLY in company B. This is what makes
+        # the divergence visible: with both companies configured, a read off the wrong one
+        # still returns A currency and the amount comes out the same, so the test would
+        # pass either way and prove nothing.
+        cls.category_b_only = cls.env["product.category"].create(
+            {"name": "SCV only in B", "property_cost_method": "average"}
+        )
+        cls.category_b_only.with_company(cls.company_b).valuation_currency_id = cls.currency_b
+        cls.product_b_only = cls.env["product.product"].create(
+            {
+                "name": "Producto sólo B",
+                "is_storable": True,
+                "standard_price": 0.0,
+                "categ_id": cls.category_b_only.id,
+                "uom_id": cls.uom_unit.id,
+            }
+        )
+        cls.product_b_only.with_company(cls.company_b).standard_price_in_currency = 700.0
+
+    def test_valuation_currency_is_resolved_per_company(self):
+        self.assertEqual(
+            self.product.with_company(self.company).valuation_currency_id,
+            self.secondary_currency,
+        )
+        self.assertEqual(
+            self.product.with_company(self.company_b).valuation_currency_id,
+            self.currency_b,
+        )
+
+    def test_valuation_currency_absent_in_the_active_company(self):
+        """The category has a valuation currency in B and NONE in A."""
+        self.assertFalse(self.product_b_only.with_company(self.company).valuation_currency_id)
+        self.assertEqual(
+            self.product_b_only.with_company(self.company_b).valuation_currency_id,
+            self.currency_b,
+        )
+
+    def test_quant_secondary_value_uses_the_quants_company(self):
+        """A quant of company B valued while company A is the active one, on a category
+        whose valuation currency exists only in B.
+
+        Reading the guard off the ambient company answers "no valuation currency" —that is
+        true for A— and the quant is skipped, so its secondary value stays at zero even
+        though in its own company it is worth 5 x 700. The amount does not come out wrong:
+        it does not come out at all.
+        """
+        self.assertTrue(self.warehouse_b, "Company B needs a warehouse of its own.")
+        quant = (
+            self.env["stock.quant"]
+            .with_company(self.company_b)
+            .with_context(inventory_mode=True)
+            .create(
+                {
+                    "product_id": self.product_b_only.id,
+                    "location_id": self.warehouse_b.lot_stock_id.id,
+                    "inventory_quantity": 5.0,
+                }
+            )
+        )
+        quant.action_apply_inventory()
+        # Re-browsed from an env whose company is A and WITHOUT B in the context: a
+        # company-dependent field resolves off the RECORDSET's context, so reading it on
+        # the ``with_company(company_b)`` recordset used to create the quant would answer
+        # for B either way and the test would prove nothing.
+        quant_seen_from_a = self.env["stock.quant"].browse(quant.id)
+        self.assertEqual(quant_seen_from_a.env.company, self.company)
+        self.assertFalse(quant_seen_from_a.valuation_currency_id)
+        self.assertAlmostEqual(quant_seen_from_a.secondary_value, 5.0 * 700.0)