Example #1
0
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.accounts = [
            Account(name='Account 1', slug='account1', group=self.group),
            Account(name='Account 2', slug='account2', group=self.group),
            Account(name='Account 3', slug='account3', group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.add(
            TransactionEntry(account=self.accounts[0], debit=100))
        self.transaction.entry_set.add(
            TransactionEntry(account=self.accounts[1], credit=100))

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()
Example #2
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            Account(name="Account 1", slug="account1", group=self.group),
            Account(name="Account 2", slug="account2", group=self.group),
            Account(name="Account 3", slug="account3", group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.create(account=self.accounts[0], debit=100)
        self.transaction.entry_set.create(account=self.accounts[1], credit=100)

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()
Example #3
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.set_pending(user=self.user)
Example #4
0
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.set_pending(user=self.user)
Example #5
0
class EntryTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='group1', slug='group1')
        self.group.save()

        self.account = Account(name='account1',
                               slug='account1',
                               group=self.group)
        self.account.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()

        self.entry = TransactionEntry(account=self.account,
                                      debit=100,
                                      credit=100,
                                      transaction=self.transaction)

    def tearDown(self):
        self.transaction.delete()
        self.account.delete()
        self.group.delete()
        self.user.delete()

    def testDebitAndCreditInSameEntry(self):
        """Checks that setting both debit and credit does not fail"""

        self.entry.debit = 100
        self.entry.credit = 100
        self.entry.save()

    def testNegativeCredit(self):
        """Checks that inputing av negative credit raises an error"""

        self.entry.credit = -100
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()

    def testNegativeDebit(self):
        """Checks that inputing av negative debit  raises an error"""

        self.entry.debit = -100
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()

    def testDebitAndCreditSetToZero(self):
        """Checks that setting both debit and credit to zero raises error"""

        self.entry.debit = 0
        self.entry.credit = 0
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()
Example #6
0
class LogTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.set_pending(user=self.user)

    def tearDown(self):
        self.transaction.delete()
        self.group.delete()
        self.user.delete()

    def testLogEntryUniqePerType(self):
        """Checks that only one log entry of each type is allowed (except for
        pending)
        """

        for key, value in Transaction.TRANSACTION_STATE:
            log1 = TransactionLog(type=key,
                                  transaction=self.transaction,
                                  user=self.user)
            log2 = TransactionLog(type=key,
                                  transaction=self.transaction,
                                  user=self.user)
            if key != Transaction.PENDING_STATE:
                log1.save()
                with self.assertRaises(InvalidTransactionLog):
                    log2.save()

    def testLogEntryModify(self):
        """Checks that modifying log entry raises error"""

        log_entry = self.transaction.log_set.filter(
            type=Transaction.PENDING_STATE)[0]

        with self.assertRaises(InvalidTransactionLog):
            log_entry.save()

        for key, value in Transaction.TRANSACTION_STATE:
            log1 = TransactionLog(type=key,
                                  transaction=self.transaction,
                                  user=self.user)

            if key != Transaction.PENDING_STATE:
                log1.save()
                with self.assertRaises(InvalidTransactionLog):
                    log1.save()
Example #7
0
class EntryTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="group1", slug="group1")
        self.group.save()

        self.account = Account(name="account1", slug="account1", group=self.group)
        self.account.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()

        self.entry = TransactionEntry(account=self.account, debit=100, credit=100, transaction=self.transaction)

    def tearDown(self):
        self.transaction.delete()
        self.account.delete()
        self.group.delete()
        self.user.delete()

    def testDebitAndCreditInSameEntry(self):
        """Checks that setting both debit and credit does not fail"""

        self.entry.debit = 100
        self.entry.credit = 100
        self.entry.save()

    def testNegativeCredit(self):
        """Checks that inputing av negative credit raises an error"""

        self.entry.credit = -100
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()

    def testNegativeDebit(self):
        """Checks that inputing av negative debit  raises an error"""

        self.entry.debit = -100
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()

    def testDebitAndCreditSetToZero(self):
        """Checks that setting both debit and credit to zero raises error"""

        self.entry.debit = 0
        self.entry.credit = 0
        with self.assertRaises(InvalidTransactionEntry):
            self.entry.save()
Example #8
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            Account(name="Account 1", slug="account1", group=self.group),
            Account(name="Account 2", slug="account2", group=self.group),
            Account(name="Account 3", slug="account3", group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.add(TransactionEntry(account=self.accounts[0], debit=100))
        self.transaction.entry_set.add(TransactionEntry(account=self.accounts[1], credit=100))

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()
Example #9
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="group1", slug="group1")
        self.group.save()

        self.account = Account(name="account1",
                               slug="account1",
                               group=self.group)
        self.account.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()

        self.entry = self.transaction.entry_set.create(account=self.account,
                                                       debit=100,
                                                       credit=100)
Example #10
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.set_pending(user=self.user)
Example #11
0
class LogTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.set_pending(user=self.user)

    def tearDown(self):
        self.transaction.delete()
        self.group.delete()
        self.user.delete()

    def testLogEntryUniqePerType(self):
        """Checks that only one log entry of each type is allowed (except for
        pending)
        """

        for key, value in Transaction.TRANSACTION_STATE:
            log1 = TransactionLog(type=key, transaction=self.transaction, user=self.user)
            log2 = TransactionLog(type=key, transaction=self.transaction, user=self.user)
            if key != Transaction.PENDING_STATE:
                log1.save()
                with self.assertRaises(InvalidTransactionLog):
                    log2.save()

    def testLogEntryModify(self):
        """Checks that modifying log entry raises error"""

        log_entry = self.transaction.log_set.filter(type=Transaction.PENDING_STATE)[0]

        with self.assertRaises(InvalidTransactionLog):
            log_entry.save()

        for key, value in Transaction.TRANSACTION_STATE:
            log1 = TransactionLog(type=key, transaction=self.transaction, user=self.user)

            if key != Transaction.PENDING_STATE:
                log1.save()
                with self.assertRaises(InvalidTransactionLog):
                    log1.save()
Example #12
0
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='group1', slug='group1')
        self.group.save()

        self.account = Account(name='account1',
                               slug='account1',
                               group=self.group)
        self.account.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()

        self.entry = TransactionEntry(account=self.account,
                                      debit=100,
                                      credit=100,
                                      transaction=self.transaction)
Example #13
0
    def setUp(self):
        self.users = [User(username="******"), User(username="******"), User(username="******")]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name="Account 1", slug="account1", group=self.group, owner=self.users[0]),
            # Normal user account
            Account(name="Account 2", slug="account2", group=self.group, owner=self.users[1]),
            # Inactive user account
            Account(name="Account 3", slug="account3", group=self.group, owner=self.users[2], active=False),
            # Group account
            Account(
                name="Account 4", slug="account4", group=self.group, type=Account.ASSET_ACCOUNT, group_account=True
            ),
            # Inactive group account
            Account(
                name="Account 5",
                slug="account5",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                active=False,
                group_account=True,
            ),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT).account,
        ]
        for account in self.accounts:
            account.save()

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        for transaction in self.transactions.values():
            transaction.save()
            transaction.entry_set.add(TransactionEntry(account=self.accounts[0], credit=100))
            transaction.entry_set.add(TransactionEntry(account=self.accounts[1], debit=100))
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[1])
        self.transactions["Rej"].set_rejected(user=self.users[1])
Example #14
0
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="group1", slug="group1")
        self.group.save()

        self.account = Account(name="account1", slug="account1", group=self.group)
        self.account.save()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()

        self.entry = TransactionEntry(account=self.account, debit=100, credit=100, transaction=self.transaction)
Example #15
0
    def setUp(self):
        self.users = [
            User(username="******"),
            User(username="******"),
            User(username="******"),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(
                name="Account 1",
                slug="account1",
                group=self.group,
                owner=self.users[0],
            ),
            # Normal user account
            Account(
                name="Account 2",
                slug="account2",
                group=self.group,
                owner=self.users[1],
            ),
            # Inactive user account
            Account(
                name="Account 3",
                slug="account3",
                group=self.group,
                owner=self.users[2],
                active=False,
            ),
            # Group account
            Account(
                name="Account 4",
                slug="account4",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
            ),
            # Inactive group account
            Account(
                name="Account 5",
                slug="account5",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                active=False,
            ),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()
        self.account = self.accounts[0]

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        values = {"Pen": 150, "Com": 200, "Rej": 100}
        for state, transaction in self.transactions.items():
            transaction.save()
            transaction.entry_set.create(account=self.accounts[0],
                                         credit=values[state])
            transaction.entry_set.create(account=self.accounts[1],
                                         debit=values[state])
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[2])
        self.transactions["Rej"].set_rejected(user=self.users[2])
Example #16
0
class AccountTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [User(username="******"), User(username="******"), User(username="******")]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name="Account 1", slug="account1", group=self.group, owner=self.users[0]),
            # Normal user account
            Account(name="Account 2", slug="account2", group=self.group, owner=self.users[1]),
            # Inactive user account
            Account(name="Account 3", slug="account3", group=self.group, owner=self.users[2], active=False),
            # Group account
            Account(name="Account 4", slug="account4", group=self.group, type=Account.ASSET_ACCOUNT),
            # Inactive group account
            Account(name="Account 5", slug="account5", group=self.group, type=Account.ASSET_ACCOUNT, active=False),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT).account,
        ]
        for account in self.accounts:
            account.save()
        self.account = self.accounts[0]

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        values = {"Pen": 150, "Com": 200, "Rej": 100}
        for state, transaction in self.transactions.items():
            transaction.save()
            transaction.entry_set.add(TransactionEntry(account=self.accounts[0], credit=values[state]))
            transaction.entry_set.add(TransactionEntry(account=self.accounts[1], debit=values[state]))
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[2])
        self.transactions["Rej"].set_rejected(user=self.users[2])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __unicode__() contains account and group name"""

        result = self.account.__unicode__()
        self.assert_(self.account.group.name in result)
        self.assert_(self.account.name in result)

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains account and group slug"""

        result = self.account.get_absolute_url()
        self.assert_(self.account.group.slug in result)
        self.assert_(self.account.slug in result)

    def testEmptySlugRaisesError(self):
        """Checks that saving an account without a slug results in a
        ValueError"""

        self.account.slug = ""
        with self.assertRaises(ValueError):
            self.account.save()

    def testBalance(self):
        """Checks that account balance is correct"""

        # TODO: Add more transactions at different days and check balance
        # inbetween using date kwarg

        account1 = self.accounts[0]
        account2 = self.accounts[1]

        # User account after credit of 100
        self.assertEqual(int(account1.balance()), -200)
        # User account after debit of 100
        self.assertEqual(int(account2.balance()), 200)

        account1 = Account.objects.get(id=account1.id)
        account2 = Account.objects.get(id=account2.id)

        # User account after credit of 200
        self.assertEqual(int(account1.confirmed_balance_sql), -200)
        # User account after debit of 200
        self.assertEqual(int(account2.confirmed_balance_sql), 200)

        # User account after credit of 350
        self.assertEqual(int(account1.future_balance_sql), -350)
        # User account after debit of 350
        self.assertEqual(int(account2.future_balance_sql), 350)

    # --- Transaction set tests
    # Please keep in sync with Group's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that are not
        rejected"""

        set = self.account.transaction_set
        self.assertEqual(set.count(), 2)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.account.transaction_set_with_rejected
        self.assertEqual(set.count(), 3)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] in set)

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.account.pending_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] not in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.account.committed_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] not in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.account.rejected_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] not in set)
        self.assert_(self.transactions["Com"] not in set)
        self.assert_(self.transactions["Rej"] in set)
Example #17
0
class TransactionTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            Account(name="Account 1", slug="account1", group=self.group),
            Account(name="Account 2", slug="account2", group=self.group),
            Account(name="Account 3", slug="account3", group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.add(TransactionEntry(account=self.accounts[0], debit=100))
        self.transaction.entry_set.add(TransactionEntry(account=self.accounts[1], credit=100))

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()

    def tearDown(self):
        self.transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        self.user.delete()

    def testEmptyTransaction(self):
        """Checks that empty transactions are accepted"""

        transaction = Transaction(group=self.group)
        transaction.save()
        transaction.delete()

    def testEqualDebitAndCreditAmount(self):
        """Checks that transaction only accept sum(debit)==sum(credit)"""

        transaction = Transaction(group=self.group)
        transaction.save()

        transaction.entry_set.add(TransactionEntry(account=self.accounts[1], debit=200))
        transaction.entry_set.add(TransactionEntry(account=self.accounts[0], credit=100))
        with self.assertRaises(InvalidTransaction):
            transaction.set_pending(user=self.user)

        transaction.delete()

    def testAccountOnlyOnceInTransaction(self):
        """Checks that multiple credit accounts are allowed in a transaction"""

        transaction = Transaction(group=self.group)
        transaction.save()

        transaction.entry_set.add(TransactionEntry(account=self.accounts[0], debit=200))
        transaction.entry_set.add(TransactionEntry(account=self.accounts[1], credit=100))
        transaction.entry_set.add(TransactionEntry(account=self.accounts[2], credit=100))

        transaction.delete()

    def testPendingLogEntry(self):
        """Checks that a pending log entry is created"""

        transaction = self.transaction

        self.assertEqual(transaction.is_pending(), True)
        self.assertEqual(transaction.log_set.count(), 1)
        self.assertEqual(transaction.log_set.filter(type=Transaction.PENDING_STATE).count(), 1)

        pending = transaction.log_set.filter(type=Transaction.PENDING_STATE)[0].timestamp

        self.assert_(pending > self.before)
        self.assert_(pending < self.after)

    def testCommittedLogEntry(self):
        """Checks that a committed log entry is created"""

        transaction = self.transaction

        before = datetime.datetime.now()
        transaction.set_committed(user=self.user)
        after = datetime.datetime.now()

        self.assertEqual(transaction.is_committed(), True)
        self.assertEqual(transaction.log_set.count(), 2)
        self.assertEqual(transaction.log_set.filter(type=Transaction.COMMITTED_STATE).count(), 1)

        committed = transaction.log_set.filter(type=Transaction.COMMITTED_STATE)[0].timestamp

        self.assert_(committed > before)
        self.assert_(committed < after)

    def testRejectLogEntry(self):
        """Checks that pending transaction can be rejected"""

        transaction = self.transaction
        self.assertEqual(transaction.is_pending(), True)

        before = datetime.datetime.now()
        transaction.set_rejected(message="Reason for rejecting", user=self.user)
        after = datetime.datetime.now()

        self.assertEqual(transaction.is_rejected(), True)
        self.assertEqual(transaction.log_set.count(), 2)
        self.assertEqual(transaction.log_set.filter(type=Transaction.REJECTED_STATE).count(), 1)

        rejected = transaction.log_set.filter(type=Transaction.REJECTED_STATE)[0].timestamp
        self.assert_(rejected > before)
        self.assert_(rejected < after)

    def testRejectCommitedTransaction(self):
        """Tests that rejecting committed transaction fails"""

        transaction = self.transaction
        transaction.set_committed(user=self.user)

        with self.assertRaises(InvalidTransaction):
            transaction.set_rejected(message="Reason for rejecting", user=self.user)
Example #18
0
class TransactionTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username='******')
        self.user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.accounts = [
            Account(name='Account 1', slug='account1', group=self.group),
            Account(name='Account 2', slug='account2', group=self.group),
            Account(name='Account 3', slug='account3', group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.add(
            TransactionEntry(account=self.accounts[0], debit=100))
        self.transaction.entry_set.add(
            TransactionEntry(account=self.accounts[1], credit=100))

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()

    def tearDown(self):
        self.transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        self.user.delete()

    def testEmptyTransaction(self):
        """Checks that empty transactions are accepted"""

        transaction = Transaction(group=self.group)
        transaction.save()
        transaction.delete()

    def testEqualDebitAndCreditAmount(self):
        """Checks that transaction only accept sum(debit)==sum(credit)"""

        transaction = Transaction(group=self.group)
        transaction.save()

        transaction.entry_set.add(
            TransactionEntry(account=self.accounts[1], debit=200))
        transaction.entry_set.add(
            TransactionEntry(account=self.accounts[0], credit=100))
        with self.assertRaises(InvalidTransaction):
            transaction.set_pending(user=self.user)

        transaction.delete()

    def testAccountOnlyOnceInTransaction(self):
        """Checks that multiple credit accounts are allowed in a transaction"""

        transaction = Transaction(group=self.group)
        transaction.save()

        transaction.entry_set.add(
            TransactionEntry(account=self.accounts[0], debit=200))
        transaction.entry_set.add(
            TransactionEntry(account=self.accounts[1], credit=100))
        transaction.entry_set.add(
            TransactionEntry(account=self.accounts[2], credit=100))

        transaction.delete()

    def testPendingLogEntry(self):
        """Checks that a pending log entry is created"""

        transaction = self.transaction

        self.assertEqual(transaction.is_pending(), True)
        self.assertEqual(transaction.log_set.count(), 1)
        self.assertEqual(
            transaction.log_set.filter(type=Transaction.PENDING_STATE).count(),
            1)

        pending = transaction.log_set.filter(
            type=Transaction.PENDING_STATE)[0].timestamp

        self.assert_(pending > self.before)
        self.assert_(pending < self.after)

    def testCommittedLogEntry(self):
        """Checks that a committed log entry is created"""

        transaction = self.transaction

        before = datetime.datetime.now()
        transaction.set_committed(user=self.user)
        after = datetime.datetime.now()

        self.assertEqual(transaction.is_committed(), True)
        self.assertEqual(transaction.log_set.count(), 2)
        self.assertEqual(
            transaction.log_set.filter(
                type=Transaction.COMMITTED_STATE).count(), 1)

        committed = transaction.log_set.filter(
            type=Transaction.COMMITTED_STATE)[0].timestamp

        self.assert_(committed > before)
        self.assert_(committed < after)

    def testRejectLogEntry(self):
        """Checks that pending transaction can be rejected"""

        transaction = self.transaction
        self.assertEqual(transaction.is_pending(), True)

        before = datetime.datetime.now()
        transaction.set_rejected(message='Reason for rejecting',
                                 user=self.user)
        after = datetime.datetime.now()

        self.assertEqual(transaction.is_rejected(), True)
        self.assertEqual(transaction.log_set.count(), 2)
        self.assertEqual(
            transaction.log_set.filter(
                type=Transaction.REJECTED_STATE).count(), 1)

        rejected = transaction.log_set.filter(
            type=Transaction.REJECTED_STATE)[0].timestamp
        self.assert_(rejected > before)
        self.assert_(rejected < after)

    def testRejectCommitedTransaction(self):
        """Tests that rejecting committed transaction fails"""

        transaction = self.transaction
        transaction.set_committed(user=self.user)

        with self.assertRaises(InvalidTransaction):
            transaction.set_rejected(message='Reason for rejecting',
                                     user=self.user)
Example #19
0
    def setUp(self):
        self.users = [
            User(username='******'),
            User(username='******'),
            User(username='******'),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name='Account 1',
                    slug='account1',
                    group=self.group,
                    owner=self.users[0]),
            # Normal user account
            Account(name='Account 2',
                    slug='account2',
                    group=self.group,
                    owner=self.users[1]),
            # Inactive user account
            Account(name='Account 3',
                    slug='account3',
                    group=self.group,
                    owner=self.users[2],
                    active=False),
            # Group account
            Account(name='Account 4',
                    slug='account4',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT),
            # Inactive group account
            Account(name='Account 5',
                    slug='account5',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT,
                    active=False),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()
        self.account = self.accounts[0]

        self.transactions = {
            'Pen': Transaction(group=self.group),
            'Com': Transaction(group=self.group),
            'Rej': Transaction(group=self.group),
        }
        values = {
            'Pen': 150,
            'Com': 200,
            'Rej': 100,
        }
        for state, transaction in self.transactions.items():
            transaction.save()
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[0],
                                 credit=values[state]))
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[1],
                                 debit=values[state]))
            transaction.set_pending(user=self.users[0])

        self.transactions['Undef'] = Transaction(group=self.group)
        self.transactions['Undef'].save()

        self.transactions['Com'].set_committed(user=self.users[2])
        self.transactions['Rej'].set_rejected(user=self.users[2])
Example #20
0
class AccountTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [
            User(username='******'),
            User(username='******'),
            User(username='******'),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name='Account 1',
                    slug='account1',
                    group=self.group,
                    owner=self.users[0]),
            # Normal user account
            Account(name='Account 2',
                    slug='account2',
                    group=self.group,
                    owner=self.users[1]),
            # Inactive user account
            Account(name='Account 3',
                    slug='account3',
                    group=self.group,
                    owner=self.users[2],
                    active=False),
            # Group account
            Account(name='Account 4',
                    slug='account4',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT),
            # Inactive group account
            Account(name='Account 5',
                    slug='account5',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT,
                    active=False),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()
        self.account = self.accounts[0]

        self.transactions = {
            'Pen': Transaction(group=self.group),
            'Com': Transaction(group=self.group),
            'Rej': Transaction(group=self.group),
        }
        values = {
            'Pen': 150,
            'Com': 200,
            'Rej': 100,
        }
        for state, transaction in self.transactions.items():
            transaction.save()
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[0],
                                 credit=values[state]))
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[1],
                                 debit=values[state]))
            transaction.set_pending(user=self.users[0])

        self.transactions['Undef'] = Transaction(group=self.group)
        self.transactions['Undef'].save()

        self.transactions['Com'].set_committed(user=self.users[2])
        self.transactions['Rej'].set_rejected(user=self.users[2])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __unicode__() contains account and group name"""

        result = self.account.__unicode__()
        self.assert_(self.account.group.name in result)
        self.assert_(self.account.name in result)

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains account and group slug"""

        result = self.account.get_absolute_url()
        self.assert_(self.account.group.slug in result)
        self.assert_(self.account.slug in result)

    def testEmptySlugRaisesError(self):
        """Checks that saving an account without a slug results in a
        ValueError"""

        self.account.slug = ''
        with self.assertRaises(ValueError):
            self.account.save()

    def testBalance(self):
        """Checks that account balance is correct"""

        # TODO: Add more transactions at different days and check balance
        # inbetween using date kwarg

        account1 = self.accounts[0]
        account2 = self.accounts[1]

        # User account after credit of 100
        self.assertEqual(int(account1.balance()), -200)
        # User account after debit of 100
        self.assertEqual(int(account2.balance()), 200)

        account1 = Account.objects.get(id=account1.id)
        account2 = Account.objects.get(id=account2.id)

        # User account after credit of 200
        self.assertEqual(int(account1.confirmed_balance_sql), -200)
        # User account after debit of 200
        self.assertEqual(int(account2.confirmed_balance_sql), 200)

        # User account after credit of 350
        self.assertEqual(int(account1.future_balance_sql), -350)
        # User account after debit of 350
        self.assertEqual(int(account2.future_balance_sql), 350)

    # --- Transaction set tests
    # Please keep in sync with Group's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that are not
        rejected"""

        set = self.account.transaction_set
        self.assertEqual(set.count(), 2)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.account.transaction_set_with_rejected
        self.assertEqual(set.count(), 3)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] in set)

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.account.pending_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] not in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.account.committed_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] not in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.account.rejected_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] not in set)
        self.assert_(self.transactions['Com'] not in set)
        self.assert_(self.transactions['Rej'] in set)
Example #21
0
class GroupTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [
            User(username='******'),
            User(username='******'),
            User(username='******'),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name='Group 1', slug='group1')
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name='Account 1',
                    slug='account1',
                    group=self.group,
                    owner=self.users[0]),
            # Normal user account
            Account(name='Account 2',
                    slug='account2',
                    group=self.group,
                    owner=self.users[1]),
            # Inactive user account
            Account(name='Account 3',
                    slug='account3',
                    group=self.group,
                    owner=self.users[2],
                    active=False),
            # Group account
            Account(name='Account 4',
                    slug='account4',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT,
                    group_account=True),
            # Inactive group account
            Account(name='Account 5',
                    slug='account5',
                    group=self.group,
                    type=Account.ASSET_ACCOUNT,
                    active=False,
                    group_account=True),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()

        self.transactions = {
            'Pen': Transaction(group=self.group),
            'Com': Transaction(group=self.group),
            'Rej': Transaction(group=self.group),
        }
        for transaction in self.transactions.values():
            transaction.save()
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[0], credit=100))
            transaction.entry_set.add(
                TransactionEntry(account=self.accounts[1], debit=100))
            transaction.set_pending(user=self.users[0])

        self.transactions['Undef'] = Transaction(group=self.group)
        self.transactions['Undef'].save()

        self.transactions['Com'].set_committed(user=self.users[1])
        self.transactions['Rej'].set_rejected(user=self.users[1])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __unicode__() returns group name"""

        self.assertEquals(self.group.name, self.group.__unicode__())

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains group slug"""

        self.assert_(self.group.slug in self.group.get_absolute_url())

    def testEmptySlugRaisesError(self):
        """Checks that saving a group without a slug results in a ValueError"""

        self.group.slug = ''
        with self.assertRaises(ValueError):
            self.group.save()

    def testGetAccountNumberDisplay(self):
        """Check that account numbers are formated correctly."""

        self.group.account_number = '12345678901'
        self.assertEqual('1234.56.78901',
                         self.group.get_account_number_display())

    def testUserAccountSet(self):
        """Checks that get_user_account_set returns all user accounts"""

        set = self.group.get_user_account_set()
        self.assertEqual(set.count(), 3)
        self.assert_(self.accounts[0] in set)
        self.assert_(self.accounts[1] in set)
        self.assert_(self.accounts[2] in set)
        self.assert_(self.accounts[3] not in set)
        self.assert_(self.accounts[4] not in set)
        self.assert_(self.accounts[5] not in set)
        self.assert_(self.accounts[6] not in set)

    def testGroupAccountSet(self):
        """Checks that get_group_account_set returns all group accounts"""

        set = self.group.get_group_account_set()
        self.assertEqual(set.count(), 4)
        self.assert_(self.accounts[0] not in set)
        self.assert_(self.accounts[1] not in set)
        self.assert_(self.accounts[2] not in set)
        self.assert_(self.accounts[3] in set)
        self.assert_(self.accounts[4] in set)
        self.assert_(self.accounts[5] in set)
        self.assert_(self.accounts[6] in set)

    # --- Transaction set tests
    # Please keep in sync with Account's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that is not
        rejected"""

        set = self.group.transaction_set
        self.assertEqual(set.count(), 2)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.group.transaction_set_with_rejected
        self.assertEqual(set.count(), 3)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] in set)

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.group.pending_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] in set)
        self.assert_(self.transactions['Com'] not in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.group.committed_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] not in set)
        self.assert_(self.transactions['Com'] in set)
        self.assert_(self.transactions['Rej'] not in set)

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.group.rejected_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions['Pen'] not in set)
        self.assert_(self.transactions['Com'] not in set)
        self.assert_(self.transactions['Rej'] in set)
Example #22
0
class GroupTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [
            User(username="******"),
            User(username="******"),
            User(username="******"),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(
                name="Account 1",
                slug="account1",
                group=self.group,
                owner=self.users[0],
            ),
            # Normal user account
            Account(
                name="Account 2",
                slug="account2",
                group=self.group,
                owner=self.users[1],
            ),
            # Inactive user account
            Account(
                name="Account 3",
                slug="account3",
                group=self.group,
                owner=self.users[2],
                active=False,
            ),
            # Group account
            Account(
                name="Account 4",
                slug="account4",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                group_account=True,
            ),
            # Inactive group account
            Account(
                name="Account 5",
                slug="account5",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                active=False,
                group_account=True,
            ),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        for transaction in self.transactions.values():
            transaction.save()
            transaction.entry_set.create(account=self.accounts[0], credit=100)
            transaction.entry_set.create(account=self.accounts[1], debit=100)
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[1])
        self.transactions["Rej"].set_rejected(user=self.users[1])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __str__() returns group name"""

        assert str(self.group) == self.group.name

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains group slug"""

        assert self.group.slug in self.group.get_absolute_url()

    def testEmptySlugRaisesError(self):
        """Checks that saving a group without a slug results in a ValueError"""

        self.group.slug = ""
        with pytest.raises(ValueError):
            self.group.save()

    def testGetAccountNumberDisplay(self):
        """Check that account numbers are formated correctly."""

        self.group.account_number = "12345678901"
        assert "1234.56.78901" == self.group.get_account_number_display()

    def testUserAccountSet(self):
        """Checks that get_user_account_set returns all user accounts"""

        set = self.group.get_user_account_set()
        assert set.count() == 3
        assert self.accounts[0] in set
        assert self.accounts[1] in set
        assert self.accounts[2] in set
        assert self.accounts[3] not in set
        assert self.accounts[4] not in set
        assert self.accounts[5] not in set
        assert self.accounts[6] not in set

    def testGroupAccountSet(self):
        """Checks that get_group_account_set returns all group accounts"""

        set = self.group.get_group_account_set()
        assert set.count() == 4
        assert self.accounts[0] not in set
        assert self.accounts[1] not in set
        assert self.accounts[2] not in set
        assert self.accounts[3] in set
        assert self.accounts[4] in set
        assert self.accounts[5] in set
        assert self.accounts[6] in set

    # --- Transaction set tests
    # Please keep in sync with Account's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that is not
        rejected"""

        set = self.group.transaction_set
        assert set.count() == 2
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] not in set

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.group.transaction_set_with_rejected
        assert set.count() == 3
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] in set

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.group.pending_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] not in set
        assert self.transactions["Rej"] not in set

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.group.committed_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] not in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] not in set

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.group.rejected_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] not in set
        assert self.transactions["Com"] not in set
        assert self.transactions["Rej"] in set
Example #23
0
class AccountTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [
            User(username="******"),
            User(username="******"),
            User(username="******"),
        ]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(
                name="Account 1",
                slug="account1",
                group=self.group,
                owner=self.users[0],
            ),
            # Normal user account
            Account(
                name="Account 2",
                slug="account2",
                group=self.group,
                owner=self.users[1],
            ),
            # Inactive user account
            Account(
                name="Account 3",
                slug="account3",
                group=self.group,
                owner=self.users[2],
                active=False,
            ),
            # Group account
            Account(
                name="Account 4",
                slug="account4",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
            ),
            # Inactive group account
            Account(
                name="Account 5",
                slug="account5",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                active=False,
            ),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT
                                           ).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT
                                           ).account,
        ]
        for account in self.accounts:
            account.save()
        self.account = self.accounts[0]

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        values = {"Pen": 150, "Com": 200, "Rej": 100}
        for state, transaction in self.transactions.items():
            transaction.save()
            transaction.entry_set.create(account=self.accounts[0],
                                         credit=values[state])
            transaction.entry_set.create(account=self.accounts[1],
                                         debit=values[state])
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[2])
        self.transactions["Rej"].set_rejected(user=self.users[2])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __str__() contains account and group name"""

        result = str(self.account)
        assert self.account.group.name in result
        assert self.account.name in result

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains account and group slug"""

        result = self.account.get_absolute_url()
        assert self.account.group.slug in result
        assert self.account.slug in result

    def testEmptySlugRaisesError(self):
        """Checks that saving an account without a slug results in a
        ValueError"""

        self.account.slug = ""
        with pytest.raises(ValueError):
            self.account.save()

    def testBalance(self):
        """Checks that account balance is correct"""

        # TODO: Add more transactions at different days and check balance
        # inbetween using date kwarg

        account1 = self.accounts[0]
        account2 = self.accounts[1]

        # User account after credit of 100
        assert int(account1.balance()) == (-200)
        # User account after debit of 100
        assert int(account2.balance()) == 200

        account1 = Account.objects.get(id=account1.id)
        account2 = Account.objects.get(id=account2.id)

        # User account after credit of 200
        assert int(account1.confirmed_balance_sql) == (-200)
        # User account after debit of 200
        assert int(account2.confirmed_balance_sql) == 200

        # User account after credit of 350
        assert int(account1.future_balance_sql) == (-350)
        # User account after debit of 350
        assert int(account2.future_balance_sql) == 350

    # --- Transaction set tests
    # Please keep in sync with Group's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that are not
        rejected"""

        set = self.account.transaction_set
        assert set.count() == 2
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] not in set

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.account.transaction_set_with_rejected
        assert set.count() == 3
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] in set

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.account.pending_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] in set
        assert self.transactions["Com"] not in set
        assert self.transactions["Rej"] not in set

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.account.committed_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] not in set
        assert self.transactions["Com"] in set
        assert self.transactions["Rej"] not in set

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.account.rejected_transaction_set
        assert set.count() == 1
        assert self.transactions["Pen"] not in set
        assert self.transactions["Com"] not in set
        assert self.transactions["Rej"] in set
Example #24
0
class TransactionTestCase(unittest.TestCase):
    def setUp(self):
        self.user = User(username="******")
        self.user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            Account(name="Account 1", slug="account1", group=self.group),
            Account(name="Account 2", slug="account2", group=self.group),
            Account(name="Account 3", slug="account3", group=self.group),
        ]
        for account in self.accounts:
            account.save()

        self.before = datetime.datetime.now()

        self.transaction = Transaction(group=self.group)
        self.transaction.save()
        self.transaction.entry_set.create(account=self.accounts[0], debit=100)
        self.transaction.entry_set.create(account=self.accounts[1], credit=100)

        self.transaction.set_pending(user=self.user)

        self.after = datetime.datetime.now()

    def tearDown(self):
        self.transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        self.user.delete()

    def testEmptyTransaction(self):
        """Checks that empty transactions are accepted"""

        transaction = Transaction(group=self.group)
        transaction.save()
        transaction.delete()

    def testEqualDebitAndCreditAmount(self):
        """Checks that transaction only accept sum(debit)==sum(credit)"""

        transaction = Transaction(group=self.group)
        transaction.save()

        transaction.entry_set.create(account=self.accounts[1], debit=200)
        transaction.entry_set.create(account=self.accounts[0], credit=100)

        with pytest.raises(InvalidTransaction):
            transaction.set_pending(user=self.user)

        transaction.delete()

    def testAccountOnlyOnceInTransaction(self):
        """Checks that multiple credit accounts are allowed in a transaction"""

        transaction = Transaction(group=self.group)
        transaction.save()

        TransactionEntry.objects.create(account=self.accounts[0],
                                        debit=200,
                                        transaction=transaction)
        TransactionEntry.objects.create(account=self.accounts[1],
                                        credit=100,
                                        transaction=transaction)
        TransactionEntry.objects.create(account=self.accounts[2],
                                        credit=100,
                                        transaction=transaction)

        transaction.delete()

    def testPendingLogEntry(self):
        """Checks that a pending log entry is created"""

        transaction = self.transaction

        assert transaction.is_pending() is True
        assert transaction.log_set.count() == 1
        assert (transaction.log_set.filter(
            type=Transaction.PENDING_STATE).count() == 1)

        pending = transaction.log_set.filter(
            type=Transaction.PENDING_STATE)[0].timestamp

        assert pending > self.before
        assert pending < self.after

    def testCommittedLogEntry(self):
        """Checks that a committed log entry is created"""

        transaction = self.transaction

        before = datetime.datetime.now()
        transaction.set_committed(user=self.user)
        after = datetime.datetime.now()

        assert transaction.is_committed() is True
        assert transaction.log_set.count() == 2
        assert (transaction.log_set.filter(
            type=Transaction.COMMITTED_STATE).count() == 1)

        committed = transaction.log_set.filter(
            type=Transaction.COMMITTED_STATE)[0].timestamp

        assert committed > before
        assert committed < after

    def testRejectLogEntry(self):
        """Checks that pending transaction can be rejected"""

        transaction = self.transaction
        assert transaction.is_pending() is True

        before = datetime.datetime.now()
        transaction.set_rejected(message="Reason for rejecting",
                                 user=self.user)
        after = datetime.datetime.now()

        assert transaction.is_rejected() is True
        assert transaction.log_set.count() == 2
        assert (transaction.log_set.filter(
            type=Transaction.REJECTED_STATE).count() == 1)

        rejected = transaction.log_set.filter(
            type=Transaction.REJECTED_STATE)[0].timestamp
        assert rejected > before
        assert rejected < after

    def testRejectCommitedTransaction(self):
        """Tests that rejecting committed transaction fails"""

        transaction = self.transaction
        transaction.set_committed(user=self.user)

        with pytest.raises(InvalidTransaction):
            transaction.set_rejected(message="Reason for rejecting",
                                     user=self.user)
Example #25
0
class GroupTestCase(unittest.TestCase):
    def setUp(self):
        self.users = [User(username="******"), User(username="******"), User(username="******")]
        for user in self.users:
            user.save()

        self.group = Group(name="Group 1", slug="group1")
        self.group.save()

        self.accounts = [
            # Normal user account
            Account(name="Account 1", slug="account1", group=self.group, owner=self.users[0]),
            # Normal user account
            Account(name="Account 2", slug="account2", group=self.group, owner=self.users[1]),
            # Inactive user account
            Account(name="Account 3", slug="account3", group=self.group, owner=self.users[2], active=False),
            # Group account
            Account(
                name="Account 4", slug="account4", group=self.group, type=Account.ASSET_ACCOUNT, group_account=True
            ),
            # Inactive group account
            Account(
                name="Account 5",
                slug="account5",
                group=self.group,
                type=Account.ASSET_ACCOUNT,
                active=False,
                group_account=True,
            ),
            # Bank account
            self.group.roleaccount_set.get(role=RoleAccount.BANK_ACCOUNT).account,
            # Cash account
            self.group.roleaccount_set.get(role=RoleAccount.CASH_ACCOUNT).account,
        ]
        for account in self.accounts:
            account.save()

        self.transactions = {
            "Pen": Transaction(group=self.group),
            "Com": Transaction(group=self.group),
            "Rej": Transaction(group=self.group),
        }
        for transaction in self.transactions.values():
            transaction.save()
            transaction.entry_set.add(TransactionEntry(account=self.accounts[0], credit=100))
            transaction.entry_set.add(TransactionEntry(account=self.accounts[1], debit=100))
            transaction.set_pending(user=self.users[0])

        self.transactions["Undef"] = Transaction(group=self.group)
        self.transactions["Undef"].save()

        self.transactions["Com"].set_committed(user=self.users[1])
        self.transactions["Rej"].set_rejected(user=self.users[1])

    def tearDown(self):
        for transaction in self.transactions.values():
            transaction.delete()
        for account in self.accounts:
            account.delete()
        self.group.delete()
        for user in self.users:
            user.delete()

    def testUnicode(self):
        """Checks that __unicode__() returns group name"""

        self.assertEquals(self.group.name, self.group.__unicode__())

    def testAbsoluteUrl(self):
        """Checks that get_absolute_url() contains group slug"""

        self.assert_(self.group.slug in self.group.get_absolute_url())

    def testEmptySlugRaisesError(self):
        """Checks that saving a group without a slug results in a ValueError"""

        self.group.slug = ""
        with self.assertRaises(ValueError):
            self.group.save()

    def testGetAccountNumberDisplay(self):
        """Check that account numbers are formated correctly."""

        self.group.account_number = "12345678901"
        self.assertEqual("1234.56.78901", self.group.get_account_number_display())

    def testUserAccountSet(self):
        """Checks that get_user_account_set returns all user accounts"""

        set = self.group.get_user_account_set()
        self.assertEqual(set.count(), 3)
        self.assert_(self.accounts[0] in set)
        self.assert_(self.accounts[1] in set)
        self.assert_(self.accounts[2] in set)
        self.assert_(self.accounts[3] not in set)
        self.assert_(self.accounts[4] not in set)
        self.assert_(self.accounts[5] not in set)
        self.assert_(self.accounts[6] not in set)

    def testGroupAccountSet(self):
        """Checks that get_group_account_set returns all group accounts"""

        set = self.group.get_group_account_set()
        self.assertEqual(set.count(), 4)
        self.assert_(self.accounts[0] not in set)
        self.assert_(self.accounts[1] not in set)
        self.assert_(self.accounts[2] not in set)
        self.assert_(self.accounts[3] in set)
        self.assert_(self.accounts[4] in set)
        self.assert_(self.accounts[5] in set)
        self.assert_(self.accounts[6] in set)

    # --- Transaction set tests
    # Please keep in sync with Account's set tests

    def testTransactionSet(self):
        """Checks that transaction_set returns all transactions that is not
        rejected"""

        set = self.group.transaction_set
        self.assertEqual(set.count(), 2)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testTransactionSetWithRejected(self):
        """Checks that transaction_set_with_rejected returns all
        transactions"""

        set = self.group.transaction_set_with_rejected
        self.assertEqual(set.count(), 3)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] in set)

    def testPendingTransactionSet(self):
        """Checks that pending_transaction_set returns all pending
        transactions"""

        set = self.group.pending_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] in set)
        self.assert_(self.transactions["Com"] not in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testCommittedTransactionSet(self):
        """Checks that committed_transaction_set returns all committed
        transactions that are not rejected"""

        set = self.group.committed_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] not in set)
        self.assert_(self.transactions["Com"] in set)
        self.assert_(self.transactions["Rej"] not in set)

    def testRejectedTransactionSet(self):
        """Checks that rejected_transaction_set returns all rejected
        transactions"""

        set = self.group.rejected_transaction_set
        self.assertEqual(set.count(), 1)
        self.assert_(self.transactions["Pen"] not in set)
        self.assert_(self.transactions["Com"] not in set)
        self.assert_(self.transactions["Rej"] in set)