class AccountTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.account = self.parser.parse_account("Assets:Bank")
def testAccountAdd(self):
amount = self.parser.parse_value("150 EUR")
entry = self.account + amount
self.assertEqual(self.account, entry.account)
self.assertEqual(amount, entry.amount)
def testAccountSub(self):
amount = self.parser.parse_value("150 EUR")
entry = self.account - amount
self.assertEqual(self.account, entry.account)
self.assertEqual(-amount, entry.amount)
def testRoot(self):
self.assertEqual(self.parser.accounts["Assets"], self.account.root())
def testShortenedName(self):
account = self.account["Joint:Savings:Yearly:Interest:Compound:Open"]
size = 30
name = account.shortened_name(size)
self.assertLessEqual(len(name), size)
self.assertEqual(7, len(filter(lambda x: x == ':', name)))
def testSubName(self):
account = self.account["Checking"]
self.assertEqual(u'Bank:Checking', self.account.parent.sub_name(account))
self.assertIsNone(self.account.sub_name(self.parser.accounts["Test"]))
class TestTagFilters(unittest.TestCase):
def setUp(self):
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
bank_account.tags["foo"] = "bar"
self.bank = bank_account - self.parser.parse_value("33 $")
self.books = books_account + self.parser.parse_value("33 $")
self.tr = Transaction([self.bank, self.books])
self.tr.tags["baz"] = "hello world"
self.books.tags["title"] = "Necronomicon"
def testAccountTagFilter(self):
filter = Account.tag_filter("foo", "bar")
self.assertTrue(filter(self.tr, self.bank))
self.assertFalse(filter(self.tr, self.books))
def testAccountTagFilterEmpty(self):
filter = Account.tag_filter("foo")
self.assertTrue(filter(self.tr, self.bank))
self.assertFalse(filter(self.tr, self.books))
def testAccountTagFilterWrong(self):
filter = Account.tag_filter("baz")
self.assertFalse(filter(self.tr, self.bank))
self.assertFalse(filter(self.tr, self.books))
def testTransactionTagFilter(self):
filter = Transaction.tag_filter("baz", "hello world")
self.assertTrue(filter(self.tr, self.bank))
self.assertTrue(filter(self.tr, self.books))
self.assertTrue(filter(self.tr, None))
def testTransactionTagFilterEmpty(self):
filter = Transaction.tag_filter("baz", None)
self.assertTrue(filter(self.tr, self.bank))
self.assertTrue(filter(self.tr, self.books))
self.assertTrue(filter(self.tr, None))
def testTransactionTagFilterWrong(self):
filter = Transaction.tag_filter("foo", None)
self.assertFalse(filter(self.tr, self.bank))
self.assertFalse(filter(self.tr, self.books))
self.assertFalse(filter(self.tr, None))
def testTransactionAccountFilter(self):
filter = Transaction.account_tag_filter("foo", "bar")
self.assertTrue(filter(self.tr, None))
def testEntryTagFilter(self):
filter = Entry.tag_filter("title", "Necronomicon")
self.assertTrue(filter(self.tr, self.books))
self.assertFalse(filter(self.tr, self.bank))
self.assertFalse(filter(self.tr, None))
class TestFilter(unittest.TestCase):
def setUp(self):
self.three_entries = Filter(lambda tr, entry: len(tr.entries) == 3)
self.in_euro = Filter(lambda tr, entry: list(entry.amount.currencies()) == ["EUR"])
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
cash_account = self.parser.parse_account("Assets:Cash")
bank = bank_account - self.parser.parse_value("33 EUR")
books = books_account + self.parser.parse_value("33 EUR")
self.tr1 = Transaction([bank, books])
bank = bank_account - self.parser.parse_value("91 $")
books = books_account + self.parser.parse_value("40 $")
cash = cash_account + self.parser.parse_value("51 $")
self.tr2 = Transaction([bank, books, cash])
def testFilter(self):
self.assertFalse(self.three_entries(self.tr1, self.tr1.entries[0]))
self.assertTrue(self.three_entries(self.tr2, self.tr2.entries[0]))
self.assertTrue(self.in_euro(self.tr1, self.tr1.entries[0]))
self.assertFalse(self.in_euro(self.tr2, self.tr2.entries[0]))
def testFilterParse(self):
filter = Filter.parse(self.parser, lambda tr, entry: entry.account.name.startswith("Assets"))
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr1, self.tr1.entries[1]))
def testFilterInvert(self):
self.assertTrue((~self.three_entries)(self.tr1, self.tr1.entries[0]))
self.assertFalse((~self.three_entries)(self.tr2, self.tr2.entries[0]))
self.assertFalse((~self.in_euro)(self.tr1, self.tr1.entries[0]))
self.assertTrue((~self.in_euro)(self.tr2, self.tr2.entries[0]))
def testFilterAnd(self):
filter = self.three_entries & self.in_euro
self.assertFalse(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr2, self.tr2.entries[0]))
def testFilterOr(self):
filter = self.three_entries | self.in_euro
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertTrue(filter(self.tr2, self.tr2.entries[0]))
def testHasAccountFilter(self):
filter = Filter.has_account(self.parser.parse_account("Assets:Bank"))
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr1, self.tr1.entries[1]))
def testMatchesFilter(self):
filter = Filter.matches(re.compile(r"ank"))
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr1, self.tr1.entries[1]))
class TestLedger(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def testFilename(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
self.assertEqual(fixture_path("test.dat"), ledger.absolute_filename("test.dat"))
class TestCLIFilters(unittest.TestCase):
def setUp(self):
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
cash_account = self.parser.parse_account("Assets:Cash")
bank = bank_account - self.parser.parse_value("33 EUR")
books = books_account + self.parser.parse_value("33 EUR")
books.tags["foo"] = "bar"
self.tr1 = Transaction([bank, books], date=date(2009, 12, 31))
bank = bank_account - self.parser.parse_value("91 $")
books = books_account + self.parser.parse_value("40 $")
books.tags["date"] = date(2009, 3, 1)
cash = cash_account + self.parser.parse_value("51 $")
self.tr2 = Transaction([bank, books, cash], date=date(2010, 1, 1))
def testDateFilter(self):
filter = DateFilter.parse(self.parser, "2010/10/01")
self.assertEqual(date(2010, 10, 1), filter.date)
self.assertRaises(ValueError, DateFilter.parse, self.parser, "foo")
self.assertRaises(ValueError, DateFilter.parse, self.parser, "2011/15/12")
def testBeginFilter(self):
filter = BeginFilter.parse(self.parser, "2010")
self.assertFalse(filter(self.tr1, self.tr1.entries[0]))
self.assertTrue(filter(self.tr2, self.tr2.entries[0]))
self.assertFalse(filter(self.tr2, self.tr2.entries[1]))
def testEndFilter(self):
filter = EndFilter.parse(self.parser, "2010")
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr2, self.tr2.entries[0]))
self.assertTrue(filter(self.tr2, self.tr2.entries[1]))
def testExpressionFilter(self):
filter = ExpressionFilter.parse(self.parser, "entry.account.name.startswith('Assets')")
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr1, self.tr1.entries[1]))
def testExpressionFilterDate(self):
filter = ExpressionFilter.parse(self.parser, "entry.date < date('2010')")
self.assertTrue(filter(self.tr1, self.tr1.entries[0]))
self.assertFalse(filter(self.tr2, self.tr2.entries[0]))
self.assertTrue(filter(self.tr2, self.tr2.entries[1]))
def testExpressionFilterTag(self):
filter = ExpressionFilter.parse(self.parser, "entry.foo")
self.assertFalse(filter(self.tr1, self.tr1.entries[0]))
self.assertTrue(filter(self.tr1, self.tr1.entries[1]))
def setUp(self):
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
bank_account.tags["foo"] = "bar"
self.bank = bank_account - self.parser.parse_value("33 $")
self.books = books_account + self.parser.parse_value("33 $")
self.tr = Transaction([self.bank, self.books])
self.tr.tags["baz"] = "hello world"
self.books.tags["title"] = "Necronomicon"
class RegisterReportTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.report_factory = reports.get("register")
def testSimpleReport(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
sorting = MapSorting(lambda x: x.date)
report = self.report_factory(ledger, RuleCollection(), Filter.null, sorting)
records = list(report.generate())
self.assertEqual(4, len(records))
self.assertEqual(
[(u'Assets:Bank', Value.parse('1500 EUR'), Value.parse('1500 EUR')),
(u'Equity:Capital', Value.parse('-1500 EUR'), ZERO),
(u'Expenses:Books', Value.parse('35 EUR'), Value.parse('35 EUR')),
(u'Assets:Bank', Value.parse('-35 EUR'), ZERO)],
[(record.entry.account.name, record.entry.amount, record.total) for record in records])
def testReportOrdering(self):
ledger = self.parser.parse_ledger(fixture_path("sorting.dat"))
sorting = MapSorting(lambda x: x.date)
report = self.report_factory(ledger, RuleCollection(), Filter.null, sorting)
self.assertEqual(
[unicode(chr(i)) for i in xrange(ord('A'), ord('N') + 1) for _ in xrange(2)],
[record.transaction.label for record in report.generate()])
def testEmptyRegister(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
sorting = MapSorting(lambda x: x.date)
filter = self.parser.accounts["Expenses"]["Clothing"].filter()
report = self.report_factory(ledger, RuleCollection(), filter, sorting)
records = list(report.generate())
self.assertEqual(0, len(records))
class BalanceReportTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.report_factory = reports.get("balance")
def testSimpleReport(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
sorting = Sorting(lambda x: x)
report = self.report_factory(ledger, RuleCollection(), Filter.null, sorting)
self.assertEqual(
[(u'Assets:Bank', Value.parse("1465 EUR")),
(u'Equity:Capital', Value.parse("-1500 EUR")),
(u'Expenses:Books', Value.parse("35 EUR"))],
[(record.account, record.amount) for record in report.generate() if record.account])
def testEmptyBalance(self):
ledger = self.parser.parse_ledger("<test>", "")
sorting = Sorting(lambda x: x)
report = self.report_factory(ledger, RuleCollection(), Filter.null, sorting)
records = list(report.generate())
self.assertEqual(1, len(records))
self.assertIsNone(records[0].level)
class DirectiveTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.processor = ProcessorStub(self.parser.accounts)
def testDirectiveRegistry(self):
self.assertEqual(AccountDirective, Directive.directives['account'])
self.assertIsNone(Directive.directives.get('non-existing-directive'))
def testUnsupportedDirective(self):
with self.assertRaises(UnsupportedDirective) as cm:
self.parser.parse_directive("!nonexisting")
self.assertRegexpMatches(str(cm.exception), "nonexisting")
def testAccountDirective(self):
directive = AccountDirective("Assets")
self.assertIsNone(self.processor.account.name)
directive.execute(self.processor)
self.assertEqual("Assets", self.processor.account.name)
def testEndAccountDirective(self):
directive = EndAccountDirective()
self.processor.add_account_prefix("Assets")
directive.execute(self.processor)
self.assertIsNone(self.processor.account.name)
def testIncludeDirective(self):
directive = IncludeDirective("test.dat")
self.assertEqual([], self.processor.included)
directive.execute(self.processor)
self.assertEqual(["test.dat"], self.processor.included)
def testDirectiveParsing(self):
directive = self.parser.parse_directive("!include test.dat")
self.assertEqual("test.dat", directive.filename)
def setUp(self):
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
cash_account = self.parser.parse_account("Assets:Cash")
bank = bank_account - self.parser.parse_value("33 EUR")
books = books_account + self.parser.parse_value("33 EUR")
books.tags["foo"] = "bar"
self.tr1 = Transaction([bank, books], date=date(2009, 12, 31))
bank = bank_account - self.parser.parse_value("91 $")
books = books_account + self.parser.parse_value("40 $")
books.tags["date"] = date(2009, 3, 1)
cash = cash_account + self.parser.parse_value("51 $")
self.tr2 = Transaction([bank, books, cash], date=date(2010, 1, 1))
def setUp(self):
self.three_entries = Filter(lambda tr, entry: len(tr.entries) == 3)
self.in_euro = Filter(lambda tr, entry: list(entry.amount.currencies()) == ["EUR"])
self.parser = Parser()
bank_account = self.parser.parse_account("Assets:Bank")
books_account = self.parser.parse_account("Expenses:Books")
cash_account = self.parser.parse_account("Assets:Cash")
bank = bank_account - self.parser.parse_value("33 EUR")
books = books_account + self.parser.parse_value("33 EUR")
self.tr1 = Transaction([bank, books])
bank = bank_account - self.parser.parse_value("91 $")
books = books_account + self.parser.parse_value("40 $")
cash = cash_account + self.parser.parse_value("51 $")
self.tr2 = Transaction([bank, books, cash])
def setUp(self):
self.parser = Parser()
self.bank_account = self.parser.parse_account("Assets:Bank")
self.books_account = self.parser.parse_account("Expenses:Books")
self.cash_account = self.parser.parse_account("Assets:Cash")
bank = self.bank_account - self.parser.parse_value("33 EUR")
books = self.books_account + self.parser.parse_value("33 EUR")
self.tr = Transaction([bank, books])
self.rules = RuleCollection()
@Generator
def discount(entry):
amount = entry.amount * Decimal("0.1")
yield entry.account - amount
yield self.cash_account + amount
self.discount = discount
class ParserTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def testSimpleLedger(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
self.assertEqual(2, len(ledger.transactions))
def testLedgerWithTags(self):
ledger = self.parser.parse_ledger(fixture_path("tags.dat"))
self.assertEqual(2, len(ledger.transactions))
tr1 = ledger.transactions[0]
self.assertIsNotNone(tr1.tags["balance"])
self.assertEqual(date(2011, 1, 1), tr1.entries[1].date(tr1))
tr2 = ledger.transactions[1]
self.assertEqual("Dracula", tr2.entries[0].tags["title"])
def testTags(self):
self.assertEqual({ "foo":"bar" }, self.parser.parse_tags("; foo:bar \t "))
self.assertEqual({ "foo":"1", "bar":"2", "baz":"" },
self.parser.parse_tags("; :baz: foo:1 \tbar:2"))
def testTagsWithSpaces(self):
self.assertEqual({ "foo":"hello world" },
self.parser.parse_tags('; foo:"hello world"'))
self.assertEqual({ "foo":'hello "world"' },
self.parser.parse_tags('; foo:\'hello "world"\''))
self.assertEqual({ "foo":"hello world", "bar":"0", "baz":"5" },
self.parser.parse_tags(';bar:0 foo:"hello world" baz:5'))
def testParseError(self):
with self.assertRaises(PledgerException) as cm:
self.parser.parse_ledger(fixture_path("errors.dat"))
self.assertEqual(3, cm.exception.line_number)
self.assertEqual(fixture_path("errors.dat"), cm.exception.filename)
def setUp(self):
self.parser = Parser()
self.rules = RuleCollection()
class TestLedgerProcessor(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.rules = RuleCollection()
def testAccountPrefix(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
processor = LedgerProcessor(ledger, self.rules)
collector = TransactionCollector()
processor.add_listener(collector)
processor.add_account_prefix("Business")
processor.run()
for transaction, entries in collector.transactions:
for entry in entries:
self.assertEqual("Business", entry.account.root().name)
def testRemoveAccountPrefix(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
processor = LedgerProcessor(ledger, self.rules)
collector = TransactionCollector()
processor.add_listener(collector)
self.assertEqual(2, len(ledger.transactions))
processor.add_account_prefix("Business")
ledger.transactions[0].execute(processor)
for transaction, entries in collector.transactions:
for entry in entries:
self.assertEqual("Business", entry.account.root().name)
collector.transactions = []
processor.remove_account_prefix()
ledger.transactions[0].execute(processor)
for transaction, entries in collector.transactions:
for entry in entries:
self.assertNotEqual("Business", entry.account.root().name)
def testInclude(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
processor = LedgerProcessor(ledger, self.rules)
collector = TransactionCollector()
processor.add_listener(collector)
processor.run()
processor.include("extra.dat")
self.assertEqual(3, len(collector.transactions))
def testCompact(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
processor = LedgerProcessor(ledger, self.rules)
entry = ledger.transactions[1].entries[0]
self.assertEqual(Value.parse("35 EUR"), entry.amount)
# add entry
entry2 = Entry(entry.account, Value.parse("-5 EUR"))
ledger.transactions[1].entries.append(entry2)
# rebalance transaction
ledger.transactions[1].entries[1].amount += Value.parse("5 EUR")
collector = TransactionCollector()
processor.add_listener(collector)
processor.run()
self.assertEqual(2, len(collector.transactions))
_, entries = collector.transactions[1]
self.assertEqual(2, len(entries))
self.assertEqual(Value.parse("30 EUR"), entries[0].amount)
def setUp(self):
self.parser = Parser()
def setUp(self):
self.parser = Parser()
self.account = self.parser.parse_account("Assets:Bank")
def setUp(self):
self.parser = Parser()
self.report_factory = reports.get("balance")
class RuleTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.bank_account = self.parser.parse_account("Assets:Bank")
self.books_account = self.parser.parse_account("Expenses:Books")
self.cash_account = self.parser.parse_account("Assets:Cash")
bank = self.bank_account - self.parser.parse_value("33 EUR")
books = self.books_account + self.parser.parse_value("33 EUR")
self.tr = Transaction([bank, books])
self.rules = RuleCollection()
@Generator
def discount(entry):
amount = entry.amount * Decimal("0.1")
yield entry.account - amount
yield self.cash_account + amount
self.discount = discount
def testRuleOnLedger(self):
rule = Rule(Filter.has_account(self.books_account), self.discount)
self.rules.add_rule(rule)
result = []
result += self.rules.apply(self.tr, self.tr.entries[0])
result += self.rules.apply(self.tr, self.tr.entries[1])
expected = [self.bank_account - self.parser.parse_value("33.00 EUR"),
self.books_account + self.parser.parse_value("33.00 EUR"),
self.cash_account + self.parser.parse_value("3.30 EUR"),
self.books_account - self.parser.parse_value("3.30 EUR")]
self.assertItemsEqual(expected, result)
def testAccountTagRule(self):
self.books_account.tags["discount"] = self.discount
self.rules.add_rule(Account.tag_rule("discount"))
result = []
result += self.rules.apply(self.tr, self.tr.entries[0])
result += self.rules.apply(self.tr, self.tr.entries[1])
expected = [self.bank_account - self.parser.parse_value("33.00 EUR"),
self.books_account + self.parser.parse_value("33.00 EUR"),
self.cash_account + self.parser.parse_value("3.30 EUR"),
self.books_account - self.parser.parse_value("3.30 EUR")]
self.assertItemsEqual(expected, result)
class EntryTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def testParsing(self):
value = self.parser.parse_value("34 EUR")
account = self.parser.parse_account("Test Account")
entry = Entry(account, value)
self.assertEqual(entry, self.parser.parse_entry(" Test Account 34 EUR"))
def testEquality(self):
value1 = self.parser.parse_value("34 EUR")
value2 = self.parser.parse_value("12 $")
account1 = self.parser.parse_account("Test")
account2 = self.parser.parse_account("Bank")
self.assertEqual(Entry(account1, value1), Entry(account1, value1))
self.assertNotEqual(Entry(account1, value1), Entry(account2, value1))
self.assertNotEqual(Entry(account1, value1), Entry(account1, value2))
def testEntryParser(self):
entry = self.parser.parse_entry(" Expenses:Books 61 EUR ; :gift:")
self.assertEqual("Expenses:Books", entry.account.name)
self.assertEqual(Value.parse("61 EUR"), entry.amount)
self.assertItemsEqual(["gift"], entry.tags.keys())
def testEntryDict(self):
entry = self.parser.parse_entry(" Expenses:Books 61 EUR ; :gift:")
entry2 = self.parser.parse_entry(" Expenses:Books 61 EUR")
entry3 = self.parser.parse_entry(" Expenses:Books 51 EUR")
entry4 = self.parser.parse_entry(" Expenses:Books 51 EUR")
d = {}
d[entry] = True
d[entry2] = True
d[entry3] = True
d[entry4] = True
self.assertItemsEqual([entry, entry2, entry3], d.keys())
def testRepr(self):
entry = self.parser.parse_entry(" Expenses:Books 55 EUR")
s = str(entry)
self.assertRegexpMatches(s, "Expenses:Books")
self.assertRegexpMatches(s, "55.00 EUR")
def testEntryDate(self):
entry = self.parser.parse_entry(" Expenses:Books 61 EUR ; [2011/03/03]")
entry2 = self.parser.parse_entry(" Expenses:Books 61 EUR")
transaction = FakeTransaction(date=date(2011, 03, 01))
self.assertEqual(date(2011, 03, 03), entry.date(transaction))
self.assertEqual(date(2011, 03, 01), entry2.date(transaction))
def testEntryOfTransaction(self):
transaction = FakeTransaction(date=date(2011, 03, 01))
entry = self.parser.parse_entry(" Expenses:Books 61 EUR ; [2011/03/03]").of(transaction)
entry2 = self.parser.parse_entry(" Expenses:Books 61 EUR").of(transaction)
self.assertEqual(date(2011, 03, 03), entry.date)
self.assertEqual(date(2011, 03, 01), entry2.date)
class TemplateTest(unittest.TestCase):
def setUp(self):
self.template = FakeTemplate()
self.parser = Parser()
def testCall(self):
lines = []
report = FakeReport([1, 2, 3])
self.template(report, lambda x: lines.append(x))
self.assertEqual(["1", "2", "3"], lines)
def testPad(self):
text = self.template.pad("hello", 10)
self.assertEqual(" hello", text)
def testColoredPad(self):
text = self.template.pad("hello", 10, 'red')
self.assertRegexpMatches(text, " .*hello.*")
def testLPad(self):
text = self.template.lpad("hello", 10)
self.assertEqual("hello ", text)
def testColoredLPad(self):
text = self.template.lpad("hello", 10, 'red')
self.assertRegexpMatches(text, ".*hello.* ")
def testPrintValue(self):
value = Value.parse("44 EUR")
self.assertRegexpMatches(self.template.print_value(value), r'^ *44.00 EUR$')
def testPrintNegativeValue(self):
value = Value.parse("-44 EUR")
self.assertRegexpMatches(self.template.print_value(value), r'^ *\S+-44.00 EUR\S+$')
def testPrintNullValue(self):
self.assertEqual("", self.template.print_value(None))
def testPrintAccount(self):
account = self.parser.accounts["Assets:Bank:Checking:Joint"]
text = self.template.print_account(account, None)
self.assertRegexpMatches(text, "Assets:Bank:Checking:Joint")
def testPrintAccountShortened(self):
account = self.parser.accounts["Assets:Bank:Checking:Joint"]
text = self.template.print_account(account, 20)
self.assertRegexpMatches(text, ".*:.*:.*:Joint")
self.assertLessEqual(len(filter(unicode.isalpha, text)), 20)
def testPrintLabel(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
transaction = ledger.transactions[1]
self.assertEqual("Bookshop", transaction.label)
text = self.template.print_label(transaction, 30)
self.assertRegexpMatches(text, r' *\S+Bookshop')
def testPrintClearedLabel(self):
ledger = self.parser.parse_ledger(fixture_path("simple.dat"))
transaction = ledger.transactions[1]
transaction.tags["cleared"] = True
self.assertEqual("Bookshop", transaction.label)
text = self.template.print_label(transaction, 30)
self.assertRegexpMatches(text, r' *Bookshop')
def setUp(self):
self.template = FakeTemplate()
self.parser = Parser()
def setUp(self):
self.parser = Parser()
self.report_factory = reports.get("register")
class TransactionTest(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.bank = self.parser.accounts["Assets"]["Bank"]
self.expenses = self.parser.accounts["Expenses"]["Books"]
def testParsing(self):
str = "2011/04/15 * Bookshop\n" + \
" Assets:Bank -40 EUR\n" + \
" Expenses:Books"
value = self.parser.parse_value("40 EUR")
entry1 = Entry(self.bank, -value)
entry2 = Entry(self.expenses, value)
tr = Transaction([entry1, entry2])
self.assertEquals(tr, self.parser.parse_transaction(str))
def testParsingComments(self):
str = "; gift for wife\n" + \
"2011/05/21 * Bookshop\n" + \
" Assets:Bank -40 EUR\n" + \
" Expenses:Books"
tr = self.parser.parse_transaction(str)
value = self.parser.parse_value("40 EUR")
self.assertEqual("Assets:Bank", tr.entries[0].account.name)
self.assertEqual("Expenses:Books", tr.entries[1].account.name)
self.assertEqual(-value, tr.entries[0].amount)
self.assertEqual(value, tr.entries[1].amount)
def testEmptyTransaction(self):
str = ""
self.assertIsNone(self.parser.parse_transaction(str))
str = "; hello world"
self.assertIsNone(self.parser.parse_transaction(str))
def testParseUnbalanced(self):
str = "2011/02/05 * Bookshop\n" + \
" Assets:Bank -40 EUR\n" + \
" Expenses:Book 41 EUR"
with self.assertRaises(UnbalancedTransaction) as cm:
self.parser.parse_transaction(str)
def testParseUndefined(self):
str = "2011/02/05 * Bookshop\n" + \
" Assets:Bank\n" + \
" Expenses:Book"
with self.assertRaises(UndefinedTransaction) as cm:
self.parser.parse_transaction(str)
def testMalformedHeader(self):
str = "test 2011/02/05 * Bookshop\n" + \
" Assets:Bank -40 EUR\n" + \
" Expenses:Book"
with self.assertRaises(MalformedHeader) as cm:
self.parser.parse_transaction(str)
def testMalformedHeader2(self):
str = " 2011/02/05 * Bookshop\n" + \
" Assets:Bank -40 EUR\n" + \
" Expenses:Book"
with self.assertRaises(MalformedHeader) as cm:
self.parser.parse_transaction(str)
def testUnbalanced(self):
value = self.parser.parse_value("40 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, value)
self.assertRaises(UnbalancedTransaction, Transaction, [entry1, entry2])
def testUndefined(self):
entry1 = Entry(self.bank, None)
entry2 = Entry(self.expenses, None)
self.assertRaises(UndefinedTransaction, Transaction, [entry1, entry2])
def testDefined(self):
value = self.parser.parse_value("40 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, None)
tr = Transaction([entry1, entry2])
self.assertEqual(-value, tr.entries[-1].amount)
def testRepr(self):
value = self.parser.parse_value("50 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, None)
tr = Transaction([entry1, entry2])
self.assertRegexpMatches(repr(tr), "Transaction")
def testTransactionEntries(self):
value = self.parser.parse_value("50 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, None)
tr = Transaction([entry1, entry2])
self.assertEqual(entry1, tr[0])
self.assertEqual(entry2, tr[1])
def testAmount(self):
value = self.parser.parse_value("40 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, None)
tr = Transaction([entry1, entry2])
self.assertEqual(ZERO, tr.amount)
def testClone(self):
value = self.parser.parse_value("40 EUR")
entry1 = Entry(self.bank, value)
entry2 = Entry(self.expenses, None)
tr = Transaction([entry1, entry2])
tr2 = tr.clone()
self.assertFalse(id(tr) == id(tr2))
self.assertItemsEqual(tr.entries, tr2.entries)
self.assertEqual(tr.date, tr2.date)
self.assertEqual(tr.label, tr2.label)
def setUp(self):
self.parser = Parser()
self.processor = ProcessorStub(self.parser.accounts)
def setUp(self):
self.parser = Parser()
self.bank = self.parser.accounts["Assets"]["Bank"]
self.expenses = self.parser.accounts["Expenses"]["Books"]
