コード例 #1
0
    def test_purge(self):

        user = UserFactory()
        bankaccount = BankAccountFactory()
        tag = BankTransactionTagFactory()
        banktransaction = BankTransactionFactory()
        scheduler = BankTransactionSchedulerFactory()

        out = StringIO()
        call_command('demo', purge=True, interactive=False, stdout=out)
        self.assertEqual(
            out.getvalue(),
            'All data have been deleted.\n',
        )

        user_model = get_user_model()
        with self.assertRaises(user_model.DoesNotExist):
            user_model.objects.get(pk=user.pk)

        with self.assertRaises(BankAccount.DoesNotExist):
            BankAccount.objects.get(pk=bankaccount.pk)

        with self.assertRaises(BankTransactionTag.DoesNotExist):
            BankTransactionTag.objects.get(pk=tag.pk)

        with self.assertRaises(BankTransaction.DoesNotExist):
            BankTransaction.objects.get(pk=banktransaction.pk)

        with self.assertRaises(BankTransactionScheduler.DoesNotExist):
            BankTransactionScheduler.objects.get(pk=scheduler.pk)
コード例 #2
0
ファイル: test_templatetags.py プロジェクト: xalegor/mymoney
    def test_breadcrumb(self):

        bankaccount = BankAccountFactory()
        kwargs = {
            "bankaccount_pk": bankaccount.pk,
        }

        request = mock.Mock(path=reverse('banktransactions:create', kwargs=kwargs))
        context = breadcrumb(request)
        self.assertListEqual(
            [reverse('banktransactions:list', kwargs=kwargs)],
            [link['href'] for link in context['links']]
        )

        banktransaction = BankTransactionFactory(bankaccount=bankaccount)
        request = mock.Mock(path=reverse('banktransactions:update', kwargs={
            'pk': banktransaction.pk,
        }))
        context = breadcrumb(request, banktransaction.bankaccount.pk)
        self.assertListEqual(
            [reverse('banktransactions:list', kwargs=kwargs)],
            [link['href'] for link in context['links']]
        )

        request = mock.Mock(path=reverse('banktransactionschedulers:create', kwargs=kwargs))
        context = breadcrumb(request)
        self.assertListEqual(
            [
                reverse('banktransactions:list', kwargs=kwargs),
                reverse('banktransactionschedulers:list', kwargs=kwargs),
            ],
            [link['href'] for link in context['links']]
        )

        banktransaction = BankTransactionFactory(bankaccount=bankaccount)
        request = mock.Mock(path=reverse('banktransactionschedulers:update', kwargs={
            'pk': banktransaction.pk,
        }))
        context = breadcrumb(request, banktransaction.bankaccount.pk)
        self.assertListEqual(
            [
                reverse('banktransactions:list', kwargs=kwargs),
                reverse('banktransactionschedulers:list', kwargs=kwargs),
            ],
            [link['href'] for link in context['links']]
        )
コード例 #3
0
    def test_total_credit(self):

        total = BankTransactionScheduler.objects.get_total_credit(
            self.bankaccount)
        self.assertFalse(total)

        BankTransactionSchedulerFactory(
            amount=Decimal('15'),
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
        )
        BankTransactionSchedulerFactory(
            amount=Decimal('-35'),
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
        )
        BankTransactionSchedulerFactory(
            amount=Decimal('30'),
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
        )
        BankTransactionSchedulerFactory(
            amount=Decimal('5'),
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_WEEKLY,
        )
        # Inactive.
        BankTransactionSchedulerFactory(
            amount=Decimal('5'),
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_WEEKLY,
            status=BankTransactionScheduler.STATUS_INACTIVE,
        )
        # Not a scheduler, don't count it.
        BankTransactionFactory(
            amount=Decimal('10'),
            bankaccount=self.bankaccount,
        )

        total = BankTransactionScheduler.objects.get_total_credit(
            self.bankaccount)
        self.assertDictEqual(
            total, {
                BankTransactionScheduler.TYPE_MONTHLY: Decimal(45),
                BankTransactionScheduler.TYPE_WEEKLY: Decimal(5),
            })
コード例 #4
0
    def test_summary_queryset(self, mock_bt_timezone, mock_bts_timezone):
        mock_bt_timezone.now.return_value = datetime.date(2015, 8, 11)
        mock_bts_timezone.now.return_value = datetime.date(2015, 8, 11)

        url = reverse('banktransactionschedulers:list',
                      kwargs={'bankaccount_pk': self.bankaccount.pk})
        self.client.force_login(self.owner)

        # Nothing.
        response = self.client.get(url)
        self.assertFalse(response.context[0]['summary'])
        self.assertEqual(response.context[0]['total'], 0)

        # Only credit.
        bts1 = BankTransactionSchedulerFactory(
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            amount=Decimal('2000'),
            date=datetime.date(2015, 8, 10),
        )
        response = self.client.get(url)
        self.assertDictEqual(
            response.context[0]['summary'],
            {
                BankTransactionScheduler.TYPE_MONTHLY: {
                    'type': BankTransactionScheduler.TYPES[0][1],
                    'credit': bts1.amount,
                    'debit': 0,
                    'used': 0,
                    'remaining': bts1.amount,
                    'total': bts1.amount,
                },
            },
        )
        self.assertEqual(response.context[0]['total'], bts1.amount)

        # Add debit.
        bts2 = BankTransactionSchedulerFactory(
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            amount=Decimal('-900'),
            date=datetime.date(2015, 8, 9),
        )
        bts3 = BankTransactionSchedulerFactory(
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            amount=Decimal('-100'),
            date=datetime.date(2015, 8, 25),
        )
        response = self.client.get(url)
        self.assertDictEqual(
            response.context[0]['summary'],
            {
                BankTransactionScheduler.TYPE_MONTHLY: {
                    'type': BankTransactionScheduler.TYPES[0][1],
                    'credit': bts1.amount,
                    'debit': bts2.amount + bts3.amount,  # -1000
                    'used': 0,
                    'remaining':
                    bts1.amount + bts2.amount + bts3.amount,  # 1000
                    'total': bts1.amount + bts2.amount + bts3.amount,  # 1000
                },
            },
        )
        self.assertEqual(response.context[0]['total'],
                         bts1.amount + bts2.amount + bts3.amount)

        # Add weekly schedulers.
        bts4 = BankTransactionSchedulerFactory(
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_WEEKLY,
            amount=Decimal('-30'),
            date=datetime.date(2015, 8, 11),
        )
        bts5 = BankTransactionSchedulerFactory(
            bankaccount=self.bankaccount,
            type=BankTransactionScheduler.TYPE_WEEKLY,
            amount=Decimal('-15'),
            date=datetime.date(2015, 8, 12),
        )
        response = self.client.get(url)
        self.assertDictEqual(
            response.context[0]['summary'][
                BankTransactionScheduler.TYPE_MONTHLY],
            {
                'type': BankTransactionScheduler.TYPES[0][1],
                'credit': bts1.amount,  # 2000
                'debit': bts2.amount + bts3.amount,  # -1000
                'used': 0,
                'remaining': bts1.amount + bts2.amount + bts3.amount,  # 1000
                'total': bts1.amount + bts2.amount + bts3.amount,  # 1000
            },
        )
        self.assertDictEqual(
            response.context[0]['summary'][
                BankTransactionScheduler.TYPE_WEEKLY],
            {
                'type': BankTransactionScheduler.TYPES[1][1],
                'credit': 0,
                'debit': bts4.amount + bts5.amount,  # -45
                'used': 0,
                'remaining': bts4.amount + bts5.amount,  # -45
                'total': bts4.amount + bts5.amount,  # -45
            },
        )
        self.assertEqual(
            response.context[0]['total'], bts1.amount + bts2.amount +
            bts3.amount + bts4.amount + bts5.amount)

        # Then add bank transactions.
        bt1 = BankTransactionFactory(
            bankaccount=self.bankaccount,
            date=datetime.date(2015, 8, 10),
            amount=Decimal('-150'),
        )
        bt2 = BankTransactionFactory(
            bankaccount=self.bankaccount,
            date=datetime.date(2015, 8, 20),
            amount=Decimal('-50'),
        )
        response = self.client.get(url)
        self.assertDictEqual(
            response.context[0]['summary'][
                BankTransactionScheduler.TYPE_MONTHLY],
            {
                'type':
                BankTransactionScheduler.TYPES[0][1],
                'credit':
                bts1.amount,  # 2000
                'debit':
                bts2.amount + bts3.amount,  # -1000
                'used':
                bt1.amount + bt2.amount,  # -200
                'remaining':
                bts1.amount + bts2.amount + bts3.amount + bt1.amount +
                bt2.amount,  # 800
                'total':
                bts1.amount + bts2.amount + bts3.amount,  # 1000
            },
        )
        self.assertDictEqual(
            response.context[0]['summary'][
                BankTransactionScheduler.TYPE_WEEKLY],
            {
                'type': BankTransactionScheduler.TYPES[1][1],
                'credit': 0,
                'debit': bts4.amount + bts5.amount,  # -45
                'used': bt1.amount,  # -150
                'remaining': bts4.amount + bts5.amount + bt1.amount,  # -195
                'total': bts4.amount + bts5.amount,  # -45
            },
        )
        self.assertEqual(
            response.context[0]['total'], bts1.amount + bts2.amount +
            bts3.amount + bts4.amount + bts5.amount)
コード例 #5
0
    def handle(self, *args, **options):

        if options.get('purge'):

            if options.get('interactive'):  # pragma: no cover
                msg = "Are you sure to delete all data?"
                choice = input("%s (y/N): " % msg).strip().lower()
                if choice != 'y':
                    return

            # Deleting users only should be enough to delete all instances.
            get_user_model().objects.all().delete()
            BankAccount.objects.all().delete()
            BankTransactionTag.objects.all().delete()
            BankTransaction.objects.all().delete()
            BankTransactionScheduler.objects.all().delete()

            self.stdout.write('All data have been deleted.')
            return

        user = UserFactory(
            username=options.get('username'),
            password=options.get('password'),
            email=options.get('email'),
            user_permissions='admin',
        )

        bankaccount = BankAccountFactory(
            label=_('Current account'),
            balance=2000,
            balance_initial=150,
            currency=options.get('currency'),
            owners=[user],
        )

        tag_rent = BankTransactionTagFactory(name=_('Rent'), owner=user)
        tag_shopping = BankTransactionTagFactory(name=_('Shopping'),
                                                 owner=user)
        tag_car = BankTransactionTagFactory(name=_('Car'), owner=user)
        tag_tax = BankTransactionTagFactory(name=_('Tax'), owner=user)
        tag_restaurant = BankTransactionTagFactory(name=_('Restaurant'),
                                                   owner=user)

        today = datetime.date.today()

        BankTransactionSchedulerFactory(
            bankaccount=bankaccount,
            label=_("Rent"),
            amount=Decimal("-910"),
            date=datetime.date(today.year, today.month, 10),
            payment_method=BankTransaction.PAYMENT_METHOD_TRANSFER,
            tag=tag_rent,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            recurrence=None,
        ).clone()

        BankTransactionSchedulerFactory(
            bankaccount=bankaccount,
            label=_("Council tax"),
            amount=Decimal("-99.89"),
            date=datetime.date(today.year, today.month, 15),
            payment_method=BankTransaction.PAYMENT_METHOD_TRANSFER,
            tag=tag_tax,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            recurrence=10,
        ).clone()

        BankTransactionSchedulerFactory(
            bankaccount=bankaccount,
            label=_("Wages"),
            amount=Decimal("2615.78"),
            date=datetime.date(today.year, today.month, 5),
            payment_method=BankTransaction.PAYMENT_METHOD_TRANSFER,
            tag=None,
            type=BankTransactionScheduler.TYPE_MONTHLY,
            recurrence=None,
        ).clone()

        BankTransactionFactory(
            bankaccount=bankaccount,
            label=_("Internal transfer"),
            amount=Decimal("500"),
            date=today - relativedelta(months=1, day=28),
            reconciled=True,
            status=BankTransaction.STATUS_IGNORED,
            payment_method=BankTransaction.PAYMENT_METHOD_TRANSFER_INTERNAL,
            tag=None,
            memo="Ineed$",
        )

        BankTransactionFactory(
            bankaccount=bankaccount,
            label=_("Scratch ticket"),
            amount=Decimal("150"),
            date=today,
            reconciled=False,
            payment_method=BankTransaction.PAYMENT_METHOD_CASH,
            tag=None,
            memo="Hooray!",
        )

        BankTransactionFactory(
            bankaccount=bankaccount,
            label=_("New tires"),
            amount=Decimal("-189.59"),
            date=today - relativedelta(days=5),
            reconciled=True,
            payment_method=BankTransaction.PAYMENT_METHOD_CHECK,
            tag=tag_car,
            memo="Love my bike!",
        )

        BankTransactionFactory(
            bankaccount=bankaccount,
            label=_("Bad stuff"),
            amount=Decimal("-79.90"),
            date=datetime.date(today.year, today.month, 9),
            reconciled=True,
            payment_method=BankTransaction.PAYMENT_METHOD_CREDIT_CARD,
            tag=tag_shopping,
        )

        BankTransactionFactory(
            bankaccount=bankaccount,
            label=_("Refund"),
            amount=Decimal("49.59"),
            date=datetime.date(today.year, today.month, 15),
            reconciled=True,
            payment_method=BankTransaction.PAYMENT_METHOD_TRANSFER,
            tag=tag_shopping,
        )

        date_start = today + relativedelta(months=-1, day=15)
        date_end = today + relativedelta(months=1, day=15)
        date = date_start

        while date < date_end:

            if date <= today or date.day % 3 == 0:

                choice = [tag_shopping, tag_restaurant, None, None]
                tag = fuzzy.FuzzyChoice(choice).fuzz()

                BankTransactionFactory(
                    bankaccount=bankaccount,
                    label=tag.name if tag is not None else _('Something'),
                    amount=fuzzy.FuzzyDecimal(-100, -10),
                    date=date,
                    reconciled=date < today - relativedelta(days=-3),
                    status=BankTransaction.STATUS_ACTIVE,
                    tag=tag,
                )

            date += relativedelta(days=1)

        self.stdout.write("Data have been generated successfully.")