test_transaction.py

from unittest import main
 
from gnucash import Transaction, Book, Account, Split
from unittest_support import *
from datetime import datetime, timezone
 
from test_book import BookSession
 
class TransactionSession(BookSession):
    def setUp(self):
        self.domain1 = "gnc.engine"
        self.domain2 = "gnc.engine.scrub"
        level =  G_LOG_LEVEL_CRITICAL
        check1 = TestErrorStruct()
        check1.log_domain = self.domain1
        check1.log_level = level
        check1.msg = "[xaccScrubUtilityGetOrMakeAccount()] No currency specified!"
        test_add_error(check1)
        check2 = TestErrorStruct()
        check2.log_domain = self.domain1
        check2.log_level = level
        check2.msg = "[xaccTransScrubSplits()] Transaction doesn't have a currency!"
        test_add_error(check2)
        self.hdlr1 = test_set_list_handler(self.domain1, level, None)
        check3 = TestErrorStruct()
        check3.log_domain = "gnc.engine.scrub"
        check3.log_level = level
        check3.msg = "[xaccScrubUtilityGetOrMakeAccount()] No currency specified!"
        self.hdlr2 = test_set_checked_handler(self.domain2, level, check3)
        BookSession.setUp(self)
        self.trans = Transaction(self.book)
        #Evil bug means we must set a split for the transaction before making
        #any other changes (is slightly useful for later tests)
        self.split = Split(self.book)
        self.split.SetParent(self.trans)
        
        self.trans.SetCurrency(self.currencycurrency)
 
    def tearDown(self):
        g_log_remove_handler(self.domain1, self.hdlr1)
        g_log_remove_handler(self.domain2, self.hdlr2)
        test_clear_error_list ()
 
class TestTransaction(TransactionSession):
    def test_equal(self):
        TRANS = self.transtrans
        self.assertTrue( TRANS.Equal(self.transtrans, True, False, False, False) )
        # test __eq__ implementation
        SPLIT = Split(self.book)
        SPLIT.SetParent(TRANS)
        self.assertTrue( self.transtrans == SPLIT.GetParent() )
        self.assertTrue( self.transtrans != Transaction(self.book) )
 
    def test_clone(self):
        domain = "gnc.engine"
        level =  G_LOG_LEVEL_WARNING
        check = TestErrorStruct()
        check.log_domain = domain
        check.log_level = level
        check.msg = "[xaccTransEqual()] GUIDs differ"
        hdlr = test_set_checked_handler(domain, level, check)
 
        TRANS = self.transtrans.Clone()
       #Clone and original should have different GUIDs
        self.assertFalse( TRANS.Equal(self.transtrans, True, False, False, False) )
        #Clone and original should have the same balance
        self.assertTrue( TRANS.Equal(self.transtrans, False, False, True, False) )
 
        g_log_remove_handler(domain, hdlr)
 
    def test_setcurrency(self):
        self.assertTrue( self.currencycurrencycurrency.equal( self.transtrans.GetCurrency() ) )
 
    def test_edit(self):
        self.assertFalse( self.transtrans.IsOpen() )
        self.transtrans.BeginEdit()
        self.assertTrue( self.transtrans.IsOpen() )
        self.transtrans.CommitEdit()
        self.assertFalse( self.transtrans.IsOpen() )
 
    def test_rollback(self):
        self.assertEqual( '', self.transtrans.GetDescription() )
        self.transtrans.BeginEdit()
        DESC = 'Food'
        self.transtrans.SetDescription(DESC)
        self.assertEqual( DESC, self.transtrans.GetDescription() )
        self.transtrans.RollbackEdit()
        self.assertEqual( '', self.transtrans.GetDescription() )
 
    def test_findsplit(self):
        ACCT = Account(self.book)
        ACCT.SetCommodity(self.currencycurrencycurrency)
        self.splitsplit.SetAccount( ACCT )
        SPLIT = self.transtrans.FindSplitByAccount( ACCT )
        self.assertTrue( SPLIT.Equal(self.splitsplit, True, False, False) )
 
    def test_getsplit(self):
        SPLIT = self.transtrans.GetSplit(0)
        self.assertTrue( SPLIT.Equal(self.splitsplit, True, False, False) )
 
    def test_getsplitindex(self):
        self.assertEqual( 0, self.transtrans.GetSplitIndex(self.splitsplit) )
 
    def test_countsplits(self):
        self.assertEqual( 1, self.transtrans.CountSplits() )
 
    def test_readonly(self):
        self.assertEqual( None, self.transtrans.GetReadOnly() )
        REASON = 'none'
        self.transtrans.SetReadOnly(REASON)
        self.assertEqual( REASON, self.transtrans.GetReadOnly() )
        self.transtrans.ClearReadOnly()
        self.assertEqual( None, self.transtrans.GetReadOnly() )
 
    def test_num(self):
        NUM = '5'
        self.assertEqual( '', self.transtrans.GetNum() )
        self.transtrans.SetNum(NUM)
        self.assertEqual( NUM, self.transtrans.GetNum() )
 
    def test_description(self):
        DESCR = 'Groceries'
        self.assertEqual( '', self.transtrans.GetDescription() )
        self.transtrans.SetDescription(DESCR)
        self.assertEqual( DESCR, self.transtrans.GetDescription() )
 
    def test_notes(self):
        NOTE = 'For dinner party'
        self.assertEqual( None, self.transtrans.GetNotes() )
        self.transtrans.SetNotes(NOTE)
        self.assertEqual( NOTE, self.transtrans.GetNotes() )
 
    def test_date(self):
        ZERODATE=datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
        DATE=datetime(2020, 2, 20, 10, 59, 0, tzinfo=timezone.utc)
        self.assertEqual(ZERODATE, self.transtrans.GetDate().astimezone(timezone.utc))
        self.transtrans.SetDate(DATE.day, DATE.month, DATE.year)
        self.assertEqual(DATE, self.transtrans.GetDate().astimezone(timezone.utc))
 
if __name__ == '__main__':
    main()