test_price_and_wrapping.py

"""Tests for GncPrice / GncPriceDB / GncLot return-type wrapping.
 
All tests create data programmatically in in-memory sessions so they run
without any external data files or XML backend.
"""
 
import warnings
from datetime import datetime
from unittest import TestCase, main
 
from gnucash import (
    Account,
    Book,
    GncCommodity,
    GncNumeric,
    GncPrice,
    PriceSource,
    Session,
    Split,
    Transaction,
)
from gnucash.gnucash_core import GncCommodityNamespace, GncLot, GncPriceDB
 
 
# ---------------------------------------------------------------------------
# Helper: set up an in-memory book with a commodity and prices
# ---------------------------------------------------------------------------
class PriceSession(TestCase):
    """Base class that creates a session with a custom commodity and prices."""
 
    def setUp(self):
        self.ses = Session()
        self.book = self.ses.get_book()
        self.table = self.book.get_table()
        self.usd = self.table.lookup("CURRENCY", "USD")
 
        # Create a custom commodity
        self.test_comm = GncCommodity(
            self.book, "Test Stock", "NASDAQ", "TSTK", "TSTK", 10000
        )
        self.table.insert(self.test_comm)
 
        # Add prices to the price DB
        self.pricedb = self.book.get_price_db()
 
        self.price1 = GncPrice(self.book)
        self.price1.set_commodity(self.test_comm)
        self.price1.set_currency(self.usd)
        self.price1.set_time64(datetime(2025, 1, 15))
        self.price1.set_value(GncNumeric(4200, 100))  # 42.00
        self.price1.set_typestr("last")
        self.pricedb.add_price(self.price1)
 
        self.price2 = GncPrice(self.book)
        self.price2.set_commodity(self.test_comm)
        self.price2.set_currency(self.usd)
        self.price2.set_time64(datetime(2025, 6, 15))
        self.price2.set_value(GncNumeric(4500, 100))  # 45.00
        self.price2.set_typestr("last")
        self.pricedb.add_price(self.price2)
 
    def tearDown(self):
        self.ses.end()
 
 
# ---------------------------------------------------------------------------
# Test: GncPrice and GncPriceDB wrapping
# ---------------------------------------------------------------------------
class TestGncPriceWrapping(PriceSession):
    """Verify that GncPrice / GncPriceDB methods return properly wrapped
    Python objects instead of raw SwigPyObjects."""
 
    # -- GncPriceDB single-price lookups --
 
    def test_lookup_latest_returns_gnc_price(self):
        price = self.pricedb.lookup_latest(self.test_commtest_comm, self.usd)
        self.assertIsNotNone(price, "No price found for TSTK/USD")
        self.assertIsInstance(price, GncPrice)
 
    def test_nth_price_returns_gnc_price(self):
        price = self.pricedb.nth_price(self.test_commtest_comm, 0)
        self.assertIsNotNone(price, "nth_price(TSTK, 0) returned None")
        self.assertIsInstance(price, GncPrice)
 
    # -- GncPrice attribute methods --
 
    def test_get_commodity_returns_gnc_commodity(self):
        price = self.pricedb.lookup_latest(self.test_commtest_comm, self.usd)
        self.assertIsNotNone(price)
        comm = price.get_commodity()
        self.assertIsInstance(comm, GncCommodity)
 
    def test_get_currency_returns_gnc_commodity(self):
        price = self.pricedb.lookup_latest(self.test_commtest_comm, self.usd)
        self.assertIsNotNone(price)
        curr = price.get_currency()
        self.assertIsInstance(curr, GncCommodity)
 
    def test_get_value_returns_gnc_numeric(self):
        price = self.pricedb.lookup_latest(self.test_commtest_comm, self.usd)
        self.assertIsNotNone(price)
        val = price.get_value()
        self.assertIsInstance(val, GncNumeric)
 
    def test_clone_returns_gnc_price(self):
        price = self.pricedb.lookup_latest(self.test_commtest_comm, self.usd)
        self.assertIsNotNone(price)
        cloned = price.clone(self.book)
        self.assertIsInstance(cloned, GncPrice)
 
    # -- GncPriceDB list methods --
 
    def test_lookup_latest_any_currency_returns_list_of_gnc_price(self):
        prices = self.pricedb.lookup_latest_any_currency(self.test_commtest_comm)
        self.assertIsInstance(prices, list)
        self.assertGreater(len(prices), 0,
                           "Expected at least one price for TSTK")
        for p in prices:
            self.assertIsInstance(p, GncPrice)
 
    def test_get_prices_returns_list_of_gnc_price(self):
        prices = self.pricedb.get_prices(self.test_commtest_comm, self.usd)
        self.assertIsInstance(prices, list)
        self.assertGreater(len(prices), 0)
        for p in prices:
            self.assertIsInstance(p, GncPrice)
 
    def test_lookup_nearest_in_time_any_currency(self):
        date = datetime(2025, 1, 20)
        prices = self.pricedb.lookup_nearest_in_time_any_currency_t64(
            self.test_commtest_comm, date)
        self.assertIsInstance(prices, list)
        for p in prices:
            self.assertIsInstance(p, GncPrice)
 
    def test_lookup_nearest_before_any_currency(self):
        date = datetime(2025, 7, 1)
        prices = self.pricedb.lookup_nearest_before_any_currency_t64(
            self.test_commtest_comm, date)
        self.assertIsInstance(prices, list)
        for p in prices:
            self.assertIsInstance(p, GncPrice)
 
 
# ---------------------------------------------------------------------------
# Test: GncLot.get_split_list
# ---------------------------------------------------------------------------
class TestGncLotSplitList(TestCase):
    """Verify that GncLot.get_split_list() returns wrapped Split objects.
 
    Creates a buy+sell pair on an account then scrubs lots, matching the
    pattern in test_account.py's test_assignlots.
    """
 
    def setUp(self):
        self.ses = Session()
        self.book = self.ses.get_book()
        table = self.book.get_table()
        currency = table.lookup("CURRENCY", "USD")
 
        stock = GncCommodity(self.book, "Lot Test", "COMMODITY", "LTX", "LTX", 100000)
        table.insert(stock)
 
        self.stock_acct = Account(self.book)
        self.stock_acct.SetCommodity(stock)
        root = self.book.get_root_account()
        root.append_child(self.stock_acct)
 
        cash_acct = Account(self.book)
        cash_acct.SetCommodity(currency)
        root.append_child(cash_acct)
 
        tx = Transaction(self.book)
        tx.BeginEdit()
        tx.SetCurrency(currency)
        tx.SetDateEnteredSecs(datetime.now())
        tx.SetDatePostedSecs(datetime.now())
 
        # Buy 1.3 shares
        s1 = Split(self.book)
        s1.SetParent(tx)
        s1.SetAccount(self.stock_acct)
        s1.SetAmount(GncNumeric(13, 10))
        s1.SetValue(GncNumeric(100, 1))
 
        s2 = Split(self.book)
        s2.SetParent(tx)
        s2.SetAccount(cash_acct)
        s2.SetAmount(GncNumeric(-100, 1))
        s2.SetValue(GncNumeric(-100, 1))
 
        # Sell 1.3 shares
        s3 = Split(self.book)
        s3.SetParent(tx)
        s3.SetAccount(self.stock_acct)
        s3.SetAmount(GncNumeric(-13, 10))
        s3.SetValue(GncNumeric(-100, 1))
 
        s4 = Split(self.book)
        s4.SetParent(tx)
        s4.SetAccount(cash_acct)
        s4.SetAmount(GncNumeric(100, 1))
        s4.SetValue(GncNumeric(100, 1))
 
        tx.CommitEdit()
        self.stock_acct.ScrubLots()
 
    def tearDown(self):
        self.ses.end()
 
    def test_lot_exists(self):
        lots = self.stock_acct.GetLotList()
        self.assertIsInstance(lots, list)
        self.assertGreater(len(lots), 0, "ScrubLots should have created a lot")
        for lot in lots:
            self.assertIsInstance(lot, GncLot)
 
    def test_get_split_list_returns_splits(self):
        lots = self.stock_acct.GetLotList()
        self.assertGreater(len(lots), 0)
        splits = lots[0].get_split_list()
        self.assertIsInstance(splits, list)
        self.assertGreater(len(splits), 0, "Lot has no splits")
        for s in splits:
            self.assertIsInstance(s, Split)
 
 
# ---------------------------------------------------------------------------
# Test: Split.GetNoclosingBalance and Split.GetCapGains return GncNumeric
# ---------------------------------------------------------------------------
class TestSplitGncNumericReturns(TestCase):
    """Verify that Split methods returning gnc_numeric by value are wrapped."""
 
    def setUp(self):
        self.ses = Session()
        self.book = self.ses.get_book()
        table = self.book.get_table()
        currency = table.lookup("CURRENCY", "USD")
 
        root = self.book.get_root_account()
        acct = Account(self.book)
        acct.SetCommodity(currency)
        root.append_child(acct)
 
        other = Account(self.book)
        other.SetCommodity(currency)
        root.append_child(other)
 
        tx = Transaction(self.book)
        tx.BeginEdit()
        tx.SetCurrency(currency)
        tx.SetDateEnteredSecs(datetime.now())
        tx.SetDatePostedSecs(datetime.now())
 
        self.split = Split(self.book)
        self.split.SetParent(tx)
        self.split.SetAccount(acct)
        self.split.SetAmount(GncNumeric(100, 1))
        self.split.SetValue(GncNumeric(100, 1))
 
        s2 = Split(self.book)
        s2.SetParent(tx)
        s2.SetAccount(other)
        s2.SetAmount(GncNumeric(-100, 1))
        s2.SetValue(GncNumeric(-100, 1))
 
        tx.CommitEdit()
 
    def tearDown(self):
        self.ses.end()
 
    def test_get_noclosing_balance_returns_gnc_numeric(self):
        val = self.split.GetNoclosingBalance()
        self.assertIsInstance(val, GncNumeric)
 
    def test_get_cap_gains_returns_gnc_numeric(self):
        val = self.split.GetCapGains()
        self.assertIsInstance(val, GncNumeric)
 
 
# ---------------------------------------------------------------------------
# Test: Account.get_currency_or_parent
# ---------------------------------------------------------------------------
class TestAccountCurrencyOrParent(TestCase):
    """Verify Account.get_currency_or_parent() returns GncCommodity."""
 
    def setUp(self):
        self.ses = Session()
        self.book = self.ses.get_book()
        table = self.book.get_table()
        self.usd = table.lookup("CURRENCY", "USD")
 
        root = self.book.get_root_account()
        self.acct = Account(self.book)
        self.acct.SetCommodity(self.usd)
        root.append_child(self.acct)
 
    def tearDown(self):
        self.ses.end()
 
    def test_get_currency_or_parent_returns_commodity(self):
        result = self.acct.get_currency_or_parent()
        self.assertIsNotNone(result)
        self.assertIsInstance(result, GncCommodity)
 
 
# ---------------------------------------------------------------------------
# Test: GncCommodity.obtain_twin wrapping
# ---------------------------------------------------------------------------
class TestCommodityObtainTwin(TestCase):
    """Verify GncCommodity.obtain_twin(book) returns GncCommodity."""
 
    def test_obtain_twin_same_book(self):
        ses = Session()
        book = ses.get_book()
        table = book.get_table()
        usd = table.lookup("CURRENCY", "USD")
        self.assertIsNotNone(usd)
        twin = usd.obtain_twin(book)
        self.assertIsInstance(twin, GncCommodity)
        ses.end()
 
 
# ---------------------------------------------------------------------------
# Test: GncCommodity.get_namespace_ds wrapping
# ---------------------------------------------------------------------------
class TestCommodityNamespaceDS(TestCase):
    """Verify GncCommodity.get_namespace_ds() returns
    GncCommodityNamespace."""
 
    def test_get_namespace_ds(self):
        ses = Session()
        book = ses.get_book()
        table = book.get_table()
        usd = table.lookup("CURRENCY", "USD")
        self.assertIsNotNone(usd)
        ns = usd.get_namespace_ds()
        self.assertIsInstance(ns, GncCommodityNamespace)
        ses.end()
 
 
# ---------------------------------------------------------------------------
# Test: SWIG typemap compatibility (wrapper → instance unwrap)
# ---------------------------------------------------------------------------
class TestSwigTypemapCompat(PriceSession):
    """Verify that passing a ClassFromFunctions wrapper to a C function
    still works (via the SWIG typemap) and emits a DeprecationWarning."""
 
    def test_wrapper_triggers_deprecation_warning(self):
        """Passing a GncPrice wrapper to gnucash_core_c should emit
        DeprecationWarning and still return a valid result."""
        from gnucash import gnucash_core_c as gc
 
        price = self.pricedb.lookup_latest(self.test_comm, self.usd)
        if price is None:
            self.skipTest("No price data")
 
        self.assertIsInstance(price, GncPrice)
 
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            # Pass the wrapper object directly — typemap should unwrap it
            comm_instance = gc.gnc_price_get_commodity(price)
            dep_warnings = [x for x in w
                            if issubclass(x.category, DeprecationWarning)]
            self.assertGreater(len(dep_warnings), 0,
                               "Expected DeprecationWarning from typemap")
 
    def test_raw_instance_no_warning(self):
        """Passing price.instance directly should NOT emit a warning."""
        from gnucash import gnucash_core_c as gc
 
        price = self.pricedb.lookup_latest(self.test_comm, self.usd)
        if price is None:
            self.skipTest("No price data")
 
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            comm_instance = gc.gnc_price_get_commodity(price.instance)
            dep_warnings = [x for x in w
                            if issubclass(x.category, DeprecationWarning)]
            self.assertEqual(len(dep_warnings), 0,
                             "Unexpected DeprecationWarning for .instance")
 
 
# ---------------------------------------------------------------------------
# Test: GncPriceDB.get_*_price returns GncNumeric
# ---------------------------------------------------------------------------
class TestGetPriceReturnsGncNumeric(PriceSession):
    """Verify that get_latest_price, get_nearest_price, and
    get_nearest_before_price return GncNumeric instead of raw
    _gnc_numeric."""
 
    def test_get_latest_price_returns_gnc_numeric(self):
        val = self.pricedb.get_latest_price(self.test_commtest_comm, self.usdusd)
        self.assertIsInstance(val, GncNumeric)
        self.assertNotEqual(float(val), 0.0,
                            "Expected a non-zero price for TSTK/USD")
 
    def test_get_nearest_price_returns_gnc_numeric(self):
        date = datetime(2025, 1, 20)
        val = self.pricedb.get_nearest_price(self.test_commtest_comm, self.usdusd, date)
        self.assertIsInstance(val, GncNumeric)
 
    def test_get_nearest_before_price_returns_gnc_numeric(self):
        date = datetime(2025, 7, 1)
        val = self.pricedb.get_nearest_before_price(
            self.test_commtest_comm, self.usdusd, date)
        self.assertIsInstance(val, GncNumeric)
 
    def test_get_latest_price_arithmetic(self):
        """Verify the returned GncNumeric supports arithmetic."""
        val = self.pricedb.get_latest_price(self.test_commtest_comm, self.usdusd)
        doubled = val + val
        self.assertIsInstance(doubled, GncNumeric)
        self.assertAlmostEqual(float(doubled), float(val) * 2, places=6)
 
 
# ---------------------------------------------------------------------------
# Test: ClassFromFunctions double-wrap protection
# ---------------------------------------------------------------------------
class TestDoubleWrapProtection(TestCase):
    """Verify that passing a wrapper object as instance= to a wrapper
    class constructor unwraps it instead of creating a broken object."""
 
    def test_gnc_numeric_double_wrap(self):
        original = GncNumeric(7, 3)
        double = GncNumeric(instance=original)
        self.assertEqual(double.num(), 7)
        self.assertEqual(double.denom(), 3)
 
    def test_gnc_numeric_double_wrap_arithmetic(self):
        original = GncNumeric(1, 4)
        double = GncNumeric(instance=original)
        result = double + GncNumeric(3, 4)
        self.assertAlmostEqual(float(result), 1.0, places=6)
 
    def test_gnc_commodity_double_wrap(self):
        ses = Session()
        book = ses.get_book()
        table = book.get_table()
        usd = table.lookup("CURRENCY", "USD")
        double = GncCommodity(instance=usd)
        self.assertIsInstance(double, GncCommodity)
        self.assertEqual(double.get_mnemonic(), "USD")
        ses.end()
 
    def test_raw_instance_still_works(self):
        """Passing a raw SWIG proxy as instance= must still work."""
        from gnucash import gnucash_core_c as gc
        raw = gc.gnc_numeric_create(5, 2)
        val = GncNumeric(instance=raw)
        self.assertEqual(val.num(), 5)
        self.assertEqual(val.denom(), 2)
 
 
# ---------------------------------------------------------------------------
# Test: PriceSource enum stays in sync with the C PRICE_SOURCE_* enum
# ---------------------------------------------------------------------------
class TestPriceSourceEnum(TestCase):
    """PriceSource must cover the C PRICE_SOURCE_* enum exactly, so it can't
    drift if a value is added, removed, or renumbered on the C side. Member
    names are a Python-side choice (e.g. FINANCE_QUOTE spells out FQ), so the
    check is on the set of values, which come straight from the C enum."""
 
    def test_values_match_c_enum(self):
        from gnucash import gnucash_core_c as c
        c_values = sorted(getattr(c, n) for n in dir(c)
                          if n.startswith("PRICE_SOURCE_"))
        py_values = sorted(m.value for m in PriceSource)
        self.assertEqual(py_values, c_values,
                         "PriceSource is out of sync with the C PRICE_SOURCE_* "
                         "enum -- add/remove members to match.")
 
    def test_set_source_accepts_enum(self):
        ses = Session()
        book = ses.get_book()
        table = book.get_table()
        usd = table.lookup("CURRENCY", "USD")
        stock = GncCommodity(book, "Test Stock", "NASDAQ", "TSTK", "TSTK", 10000)
        table.insert(stock)
        price = GncPrice(book)
        price.set_commodity(stock)
        price.set_currency(usd)
        price.set_source(PriceSource.FINANCE_QUOTE)
        self.assertEqual(price.get_source(), PriceSource.FINANCE_QUOTE)
        self.assertEqual(price.get_source_string(), "Finance::Quote")
        ses.end()
 
 
# ---------------------------------------------------------------------------
# Test: GncPrice.set_source_string -- deprecated, but still guards (raises on
# an unrecognized source) during the deprecation period
# ---------------------------------------------------------------------------
class TestSetSourceStringGuard(PriceSession):
    """set_source_string() is deprecated in favour of set_source(PriceSource.*),
    but while it exists it must fail loud on an unrecognized source string
    instead of silently leaving the source unchanged (the C setter no-ops).
    These tests ignore the DeprecationWarning and check the guard behaviour;
    the warning itself is covered by test_emits_deprecation_warning."""
 
    def setUp(self):
        super().setUp()
        # These tests deliberately call the deprecated method.
        self._warn_ctx = warnings.catch_warnings()
        self._warn_ctx.__enter__()
        warnings.simplefilter("ignore", DeprecationWarning)
 
    def tearDown(self):
        self._warn_ctx.__exit__(None, None, None)
        super().tearDown()
 
    def test_canonical_source_is_accepted(self):
        self.price1.set_source_string("Finance::Quote")
        self.assertEqual(self.price1.get_source_string(), "Finance::Quote")
 
    def test_unknown_source_on_fresh_price_raises(self):
        price = GncPrice(self.book)
        with self.assertRaises(ValueError):
            price.set_source_string("not-a-real-source")
 
    def test_unknown_source_does_not_clobber_existing(self):
        # The C setter no-ops on an unknown string; on a price that already has
        # a valid source that leaves the old value in place (so a bare "is the
        # source INVALID now?" check would miss it). The guard must still raise.
        self.price1.set_source_string("Finance::Quote")
        with self.assertRaises(ValueError):
            self.price1.set_source_string("totally-bogus")
        self.assertEqual(self.price1.get_source_string(), "Finance::Quote")
 
    def test_emits_deprecation_warning(self):
        with warnings.catch_warnings():
            warnings.simplefilter("error", DeprecationWarning)
            with self.assertRaises(DeprecationWarning):
                self.price1.set_source_string("Finance::Quote")
 
 
if __name__ == '__main__':
    main()