Exemple #1
0
    def test_add_two_deposits(self):
        deposit1 = Deposit(client=self.client1,
                           wallet=self.wallet1,
                           amount=Decimal(1000))
        deposit1.save()

        deposit2 = Deposit(client=self.client1,
                           wallet=self.wallet1,
                           amount=Decimal(500))
        deposit2.save()

        self.assertAlmostEqual(self.wallet1.balance,
                               Decimal(1500),
                               delta=DECIMAL_EPSILON)

        wallet_motions = WalletMotion.objects.filter(
            wallet=self.wallet1).order_by('journal_id')

        self.assertEqual(wallet_motions.count(), 2)

        self.assertAlmostEqual(wallet_motions[0].balance,
                               Decimal(1000),
                               delta=DECIMAL_EPSILON)
        self.assertAlmostEqual(wallet_motions[0].balance_end,
                               Decimal(1000),
                               delta=DECIMAL_EPSILON)

        self.assertAlmostEqual(wallet_motions[1].balance,
                               Decimal(500),
                               delta=DECIMAL_EPSILON)
        self.assertAlmostEqual(wallet_motions[1].balance_end,
                               Decimal(1500),
                               delta=DECIMAL_EPSILON)
Exemple #2
0
def create_deposits():
    templates_ids = [t.id for t in DepositTemplate.objects.all()]
    for client in User.objects.all():
        if get_or_create_clients_group() in client.groups.all():
            deposits_count = random.randint(2, 6)
            for i in range(deposits_count):
                template_id = random_element(templates_ids)
                template = DepositTemplate.objects.get(pk=template_id)
                currencies = template.currency.keys()
                currency = random_element(currencies)
                term_percent = random_element(
                    list(template.currency[currency]['percentage']))
                accounts = list(Account.objects.filter(client=client))
                if len(accounts) == 0:
                    continue
                account = accounts[0]
                account_max_amount = float(account.residue.amount) / \
                    FinanceSettings.get_instance().exchange_rates[currency]
                amount = min(random.randint(300, 20000), account_max_amount)
                deposit = Deposit.create(client, template, amount,
                                         term_percent['term'],
                                         term_percent['percentage'], currency,
                                         account.id)
                if not deposit is None and simple_event(70):
                    deposit.confirm()
    def test_save_deposit_status_ready(self):
        """
        Does ready deposit
        """
        test_account = Account.objects.create(name='Test Account',
                                              currency=CURRENCY_CUC)
        test_balance = test_account.balance

        test_date = timezone.now()
        test_amount = 100
        test_status = STATUS_READY

        deposit = Deposit(date=test_date,
                          account=test_account,
                          amount=test_amount,
                          status=test_status)

        deposit = FinanceService.save_deposit(user=self.test_user,
                                              deposit=deposit)

        # account balance incremented
        self.assertAccount(test_account=test_account,
                           test_balance=test_balance + test_amount)

        # document data auto filled
        self.assertDocument(deposit, DOC_TYPE_DEPOSIT, test_account.currency)

        # one finantial history created
        finantials = deposit.finantialdocumenthistory_set
        self.assertEqual(finantials.count(), 1)

        # finantial history info
        finantial = finantials.first()
        self.assertFinantialHistory(test_finantial_history=finantial,
                                    test_document=deposit,
                                    test_user=self.test_user,
                                    test_old_status=None,
                                    test_new_status=test_status)

        # one accounting history created
        accountings = deposit.accountingdocumenthistory_set
        self.assertEqual(accountings.count(), 1)

        # accounting history info
        accounting = accountings.first()
        operation = Operation.objects.get(pk=accounting.operation_id)

        # one movement created
        movements = operation.operationmovement_set
        self.assertEqual(movements.count(), 1)

        # movement info
        movement = movements.first()
        self.assertMovement(test_movement=movement,
                            test_account=test_account,
                            test_movement_type=MOVEMENT_TYPE_INPUT,
                            test_amount=test_amount)
Exemple #4
0
    def test_add_deposit(self):
        deposit = Deposit(client=self.client1,
                          wallet=self.wallet1,
                          amount=Decimal(1000))
        deposit.save()

        # properties
        self.assertIsNotNone(deposit.pk)
        self.assertEqual(deposit.amount, Decimal(1000))
        self.assertIsNotNone(deposit.wallet)
        self.assertIsNotNone(deposit.journal)

        # wallet balance
        self.assertEqual(deposit.amount, self.wallet1.balance)

        # wallet motions
        wallet_motion = WalletMotion.objects.get(journal=deposit.journal,
                                                 wallet=deposit.wallet)
        self.assertEqual(deposit.amount, wallet_motion.balance)
        self.assertEqual(deposit.amount, wallet_motion.balance_end)
    def test_save_deposit_status_draft(self):
        """
        Does draft deposit
        """
        test_account = Account.objects.create(name='Test Account',
                                              currency=CURRENCY_CUC)
        test_balance = test_account.balance

        test_date = timezone.now()
        test_amount = 100
        test_status = STATUS_DRAFT

        deposit = Deposit(date=test_date,
                          account=test_account,
                          amount=test_amount,
                          status=test_status)

        deposit = FinanceService.save_deposit(user=self.test_user,
                                              deposit=deposit)

        # account balance unchanged
        self.assertAccount(test_account=test_account,
                           test_balance=test_balance)

        # document data auto filled
        self.assertDocument(deposit, DOC_TYPE_DEPOSIT, test_account.currency)

        # one finantial history created
        finantials = deposit.finantialdocumenthistory_set
        self.assertEqual(finantials.count(), 1)

        # finantial history info
        finantial = finantials.first()
        self.assertFinantialHistory(test_finantial_history=finantial,
                                    test_document=deposit,
                                    test_user=self.test_user,
                                    test_old_status=None,
                                    test_new_status=test_status)

        # no accounting history created
        accountings = deposit.accountingdocumenthistory_set
        self.assertEqual(accountings.count(), 0)
    def test_save_deposit_ready_then_amount_account(self):
        """
        Does ready deposit and then change amount and account
        """
        test_account1 = Account.objects.create(name='Test Account1',
                                               currency=CURRENCY_CUC)
        test_balance1 = test_account1.balance

        test_date = timezone.now()
        test_amount1 = 100
        test_status = STATUS_READY

        deposit = Deposit(date=test_date,
                          account=test_account1,
                          amount=test_amount1,
                          status=test_status)

        deposit = FinanceService.save_deposit(user=self.test_user,
                                              deposit=deposit)

        # account balance incremented
        self.assertAccount(test_account=test_account1,
                           test_balance=test_balance1 + test_amount1)

        # document data auto filled
        self.assertDocument(deposit, DOC_TYPE_DEPOSIT, test_account1.currency)

        # one finantial history created
        finantials = deposit.finantialdocumenthistory_set
        self.assertEqual(finantials.count(), 1)

        # finantial history info
        finantial = finantials.first()
        self.assertFinantialHistory(test_finantial_history=finantial,
                                    test_document=deposit,
                                    test_user=self.test_user,
                                    test_old_status=None,
                                    test_new_status=test_status)

        # one accounting history created
        accountings = deposit.accountingdocumenthistory_set
        self.assertEqual(accountings.count(), 1)

        # accounting history info
        accounting = accountings.first()
        operation = Operation.objects.get(pk=accounting.operation_id)

        # one movement created
        movements = operation.operationmovement_set
        self.assertEqual(movements.count(), 1)

        # movement info
        movement = movements.first()
        self.assertMovement(test_movement=movement,
                            test_account=test_account1,
                            test_movement_type=MOVEMENT_TYPE_INPUT,
                            test_amount=test_amount1)

        test_account2 = Account.objects.create(name='Test Account2',
                                               currency=CURRENCY_USD)
        test_balance2 = test_account2.balance

        test_amount2 = 50

        deposit.account = test_account2
        deposit.amount = test_amount2

        deposit = FinanceService.save_deposit(user=self.test_user,
                                              deposit=deposit)

        # account balance updated
        self.assertAccount(test_account=test_account1,
                           test_balance=test_balance1)
        self.assertAccount(test_account=test_account2,
                           test_balance=test_balance2 + test_amount2)

        # document data auto filled
        self.assertDocument(deposit, DOC_TYPE_DEPOSIT, test_account2.currency)

        # no aditional finantial history
        finantials = deposit.finantialdocumenthistory_set
        self.assertEqual(finantials.count(), 1)

        # two accounting history created
        accountings = deposit.accountingdocumenthistory_set
        self.assertEqual(accountings.count(), 3)

        elements = accountings.all()

        # accounting history info
        accounting = elements[1]
        operation = Operation.objects.get(pk=accounting.operation_id)

        # one movement created
        movements = operation.operationmovement_set
        self.assertEqual(movements.count(), 1)

        # movement info
        movement = movements.first()
        self.assertMovement(test_movement=movement,
                            test_account=test_account2,
                            test_movement_type=MOVEMENT_TYPE_INPUT,
                            test_amount=test_amount2)

        # accounting history info
        accounting = elements[2]
        operation = Operation.objects.get(pk=accounting.operation_id)

        # one movement created
        movements = operation.operationmovement_set
        self.assertEqual(movements.count(), 1)

        # movement info
        movement = movements.first()
        self.assertMovement(test_movement=movement,
                            test_account=test_account1,
                            test_movement_type=MOVEMENT_TYPE_OUTPUT,
                            test_amount=test_amount1)