def test_update_form(self):
banktransactiontag = BankTransactionTagFactory(owner=self.superowner)
url = reverse('banktransactiontags:update', kwargs={
'pk': banktransactiontag.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('owner', form.fields)
form['name'] = 'rename'
response = form.submit().maybe_follow()
banktransactiontag.refresh_from_db()
self.assertEqual(banktransactiontag.name, 'rename')
self.assertEqual(banktransactiontag.owner.pk, self.superowner.pk)
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transaction tag %(name)s was updated successfully.' % {
'name': banktransactiontag.name
},
[message.message for message in storage],
)
def test_fields(self):
tag1 = BankTransactionTagFactory(owner=self.superowner)
tag2 = BankTransactionTagFactory(owner=self.superowner)
BankTransactionTagFactory()
banktransactions = [
BankTransactionFactory(bankaccount=self.bankaccount),
BankTransactionFactory(bankaccount=self.bankaccount),
BankTransactionFactory(bankaccount=self.bankaccount),
]
url = reverse('banktransactions:list',
kwargs={'bankaccount_pk': self.bankaccount.pk})
form = self.app.get(url, user='******').form
self.assertListEqual(
sorted([option[0] for option in form['tags'].options]),
[str(tag1.pk), str(tag2.pk)])
for banktransaction in banktransactions:
self.assertIn('banktransaction_' + str(banktransaction.pk),
form.fields)
self.assertListEqual(
['delete', 'reconcile', 'unreconcile'],
sorted([option[0] for option in form['operation'].options]))
form = self.app.get(url, user='******').form
self.assertNotIn('operation', form.fields)
def setUpTestData(cls):
cls.owner = UserFactory(username='******')
cls.bankaccount = BankAccountFactory(owners=[cls.owner])
cls.banktransactiontags = [
BankTransactionTagFactory(owner=cls.owner),
BankTransactionTagFactory(owner=cls.owner),
BankTransactionTagFactory(owner=cls.owner),
]
def test_delete_bankaccount(self):
bankaccount = BankAccountFactory()
tag = BankTransactionTagFactory()
BankTransactionFactory(bankaccount=bankaccount, tag=tag)
pk = bankaccount.pk
bankaccount.delete()
self.assertEqual(BankTransaction.objects.filter(bankaccount__pk=pk).count(), 0)
# Should not be deleted.
tag.refresh_from_db()
def setUpTestData(cls):
cls.owner = UserFactory(username='******')
cls.superowner = UserFactory(username='******',
user_permissions='admin')
cls.bankaccount = BankAccountFactory(
owners=[cls.owner, cls.superowner])
cls.banktransactiontags = [
BankTransactionTagFactory(owner=cls.owner),
BankTransactionTagFactory(owner=cls.owner),
BankTransactionTagFactory(owner=cls.superowner),
BankTransactionTagFactory(),
]
cls.url = reverse('banktransactions:list',
kwargs={'bankaccount_pk': cls.bankaccount.pk})
def test_delete_bankaccount(self):
bankaccount = BankAccountFactory()
tag = BankTransactionTagFactory()
BankTransactionFactory(bankaccount=bankaccount, tag=tag)
pk = bankaccount.pk
bankaccount.delete()
self.assertEqual(
BankTransaction.objects.filter(bankaccount__pk=pk).count(),
0,
)
# Should not be deleted.
tag.refresh_from_db()
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)
def test_delete_form(self):
banktransactiontag = BankTransactionTagFactory(owner=self.superowner)
url = reverse('banktransactiontags:delete', kwargs={
'pk': banktransactiontag.pk
})
response = self.app.get(url, user='******')
response = response.click(description=_('Cancel'))
self.assertEqual(response.request.path, reverse('banktransactiontags:list'))
banktransactiontag.refresh_from_db()
response = (self.app.get(url, user='******')
.form.submit()
.maybe_follow())
self.assertEqual(response.request.path, reverse('banktransactiontags:list'))
with self.assertRaises(BankTransactionTag.DoesNotExist):
banktransactiontag.refresh_from_db()
def test_update_form(self):
banktransactiontag = BankTransactionTagFactory(owner=self.superowner)
url = reverse('banktransactiontags:update',
kwargs={'pk': banktransactiontag.pk})
form = self.app.get(url, user='******').form
self.assertNotIn('owner', form.fields)
form['name'] = 'rename'
response = form.submit().maybe_follow()
banktransactiontag.refresh_from_db()
self.assertEqual(banktransactiontag.name, 'rename')
self.assertEqual(banktransactiontag.owner.pk, self.superowner.pk)
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transaction tag %(name)s was updated successfully.' %
{'name': banktransactiontag.name},
[message.message for message in storage],
)
def test_redirect_form(self):
# Check on create form.
url = reverse('banktransactiontags:create')
form = self.app.get(url, user='******').form
self.assertFalse(form['redirect'].checked)
edit = {
'name': 'test redirect',
'redirect': True,
}
for name, value in edit.items():
form[name] = value
response = form.submit()
self.assertRedirects(response, url + '?self-redirect=1')
response = response.maybe_follow()
self.assertTrue(response.form['redirect'].checked)
# Not on update form.
banktransactiontag = BankTransactionTagFactory(owner=self.superowner)
url = reverse('banktransactiontags:update',
kwargs={'pk': banktransactiontag.pk})
form = self.app.get(url, user='******').form
self.assertNotIn('redirect', form.fields)
def test_delete_form(self):
banktransactiontag = BankTransactionTagFactory(owner=self.superowner)
url = reverse('banktransactiontags:delete',
kwargs={'pk': banktransactiontag.pk})
response = self.app.get(url, user='******')
response = response.click(description=_('Cancel'))
self.assertEqual(response.request.path,
reverse('banktransactiontags:list'))
banktransactiontag.refresh_from_db()
response = (self.app.get(
url, user='******').form.submit().maybe_follow())
self.assertEqual(response.request.path,
reverse('banktransactiontags:list'))
with self.assertRaises(BankTransactionTag.DoesNotExist):
banktransactiontag.refresh_from_db()
def test_update_form(self):
tag1 = BankTransactionTagFactory(owner=self.superowner)
tag2 = BankTransactionTagFactory(owner=self.superowner)
banktransactionscheduler = BankTransactionSchedulerFactory(
bankaccount=self.bankaccount,
tag=tag1,
type=BankTransactionScheduler.TYPE_MONTHLY,
recurrence=None,
status=BankTransactionScheduler.STATUS_ACTIVE,
)
url = reverse('banktransactionschedulers:update', kwargs={
'pk': banktransactionscheduler.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('bankaccount', form.fields)
self.assertNotIn('currency', form.fields)
self.assertNotIn('reconciled', form.fields)
self.assertNotIn('scheduled', form.fields)
self.assertNotIn('last_action', form.fields)
self.assertNotIn('state', form.fields)
edit = {
'amount': '-789.45',
'tag': str(tag2.pk),
'type': BankTransactionScheduler.TYPE_WEEKLY,
'recurrence': 10,
'status': BankTransactionScheduler.STATUS_INACTIVE,
}
for name, value in edit.items():
form[name] = value
response = form.submit().maybe_follow()
banktransactionscheduler.refresh_from_db()
self.assertEqual(
banktransactionscheduler.amount,
Decimal(edit['amount'])
)
self.assertEqual(banktransactionscheduler.tag.pk, tag2.pk)
self.assertEqual(
banktransactionscheduler.type,
BankTransactionScheduler.TYPE_WEEKLY
)
self.assertEqual(
banktransactionscheduler.recurrence,
edit['recurrence']
)
self.assertEqual(
banktransactionscheduler.status,
edit['status']
)
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transaction scheduler %(label)s was updated successfully.' % {
'label': banktransactionscheduler.label
},
[message.message for message in storage],
)
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.")
def test_field_tag(self):
tag1 = BankTransactionTagFactory(owner=self.superowner)
tag2 = BankTransactionTagFactory(owner=self.superowner)
tag3 = BankTransactionTagFactory(owner=self.superowner)
tag4 = BankTransactionTagFactory()
url = reverse('banktransactions:create', kwargs={
'bankaccount_pk': self.bankaccount.pk
})
form = self.app.get(url, user='******').form
# Check available options.
self.assertListEqual(
[''] + sorted([int(option[0]) for option in form['tag'].options[1:]]),
['', tag1.pk, tag2.pk, tag3.pk]
)
# Test with a fake tag.
edit = {
'label': 'test fake tags',
'amount': '-154.12',
}
for name, value in edit.items():
form[name] = value
form['tag'].force_value(['-1'])
response = form.submit().maybe_follow()
self.assertFormError(
response,
'form',
'tag',
[
'Select a valid choice. That choice is not one of the '
'available choices.'
]
)
with self.assertRaises(BankTransaction.DoesNotExist):
BankTransaction.objects.get(label=edit['label'])
# Test with with a non-owner tag.
banktransaction = BankTransactionFactory(bankaccount=self.bankaccount)
form = self.app.get(
reverse('banktransactions:update', kwargs={
'pk': banktransaction.pk
}),
user='******'
).form
edit = {
'label': 'test wrong tags',
'amount': '-45.21',
}
for name, value in edit.items():
form[name] = value
form['tag'].force_value([str(tag4.pk)])
response = form.submit().maybe_follow()
self.assertFormError(
response,
'form',
'tag',
[
'Select a valid choice. That choice is not one of the '
'available choices.'
]
)
with self.assertRaises(BankTransaction.DoesNotExist):
BankTransaction.objects.get(label=edit['label'])
# Finally test adding tag.
form = self.app.get(url, user='******').form
edit = {
'label': 'test tags',
'amount': '-154.12',
'tag': str(tag1.pk),
}
for name, value in edit.items():
form[name] = value
response = form.submit().maybe_follow()
banktransaction = BankTransaction.objects.get(label=edit['label'])
self.assertEqual(
str(banktransaction.tag.pk),
edit['tag']
)
def test_update_form(self):
tag = BankTransactionTagFactory(owner=self.superowner)
banktransaction = BankTransactionFactory(
bankaccount=self.bankaccount,
amount='-78.26',
date='2015-07-10',
reconciled=False,
payment_method=BankTransaction.PAYMENT_METHOD_CREDIT_CARD,
memo="",
tag=BankTransactionTagFactory(),
)
url = reverse('banktransactions:update', kwargs={
'pk': banktransaction.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('currency', form.fields)
self.assertNotIn('scheduled', form.fields)
edit = {
'label': 'test update',
'amount': '15.69',
'date': '2015-01-01',
'reconciled': True,
'payment_method': BankTransaction.PAYMENT_METHOD_CASH,
'memo': "Ooops, typo errors!",
'tag': str(tag.pk),
}
for name, value in edit.items():
form[name] = value
response = form.submit().maybe_follow()
banktransaction.refresh_from_db()
self.assertEqual(banktransaction.label, edit['label'])
self.assertEqual(banktransaction.amount, Decimal(edit['amount']))
self.assertEqual(banktransaction.currency, self.bankaccount.currency)
self.assertEqual(banktransaction.bankaccount.pk, self.bankaccount.pk)
self.assertEqual(
str(banktransaction.date),
edit['date'],
)
self.assertTrue(banktransaction.reconciled)
self.assertEqual(banktransaction.payment_method, BankTransaction.PAYMENT_METHOD_CASH)
self.assertEqual(banktransaction.memo, edit['memo'])
self.assertFalse(banktransaction.scheduled)
self.assertEqual(
str(banktransaction.tag.pk),
edit['tag'],
)
banktransaction.bankaccount.refresh_from_db()
self.assertEqual(banktransaction.bankaccount.balance, Decimal('15.69'))
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transaction %(label)s was updated successfully.' % {
'label': banktransaction.label
},
[message.message for message in storage],
)
def test_clone_succeed(self):
bankaccount = BankAccountFactory(balance=0)
# Test monthly, with recurrence.
bts = BankTransactionSchedulerFactory(
bankaccount=bankaccount,
amount=Decimal('10.23'),
date=datetime.date(2015, 1, 31),
memo="Test",
reconciled=True,
status=BankTransaction.STATUS_ACTIVE,
tag=BankTransactionTagFactory(),
type=BankTransactionScheduler.TYPE_MONTHLY,
last_action=None,
state=BankTransactionScheduler.STATE_WAITING,
recurrence=2,
)
bts.clone()
bt_clone = BankTransaction.objects.order_by('pk').last()
self.assertEqual(bt_clone.label, bts.label)
self.assertEqual(bt_clone.amount, bts.amount)
self.assertEqual(bt_clone.payment_method, bts.payment_method)
self.assertEqual(bt_clone.memo, bts.memo)
self.assertEqual(bt_clone.tag.pk, bts.tag.pk)
self.assertFalse(bt_clone.reconciled)
self.assertTrue(bt_clone.scheduled)
self.assertEqual(bt_clone.status, bts.status)
self.assertEqual(
bt_clone.date,
datetime.date(2015, 2, 28),
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('10.23'))
self.assertEqual(bts.date, bt_clone.date)
self.assertIsNotNone(bts.last_action)
self.assertEqual(bts.recurrence, 1)
self.assertEqual(bts.state, BankTransactionScheduler.STATE_FINISHED)
# Clone it again to delete it.
bts.clone()
with self.assertRaises(BankTransactionScheduler.DoesNotExist):
bts.refresh_from_db()
# Test weekly, infinity
bts = BankTransactionSchedulerFactory(
bankaccount=bankaccount,
amount=Decimal(-45.74),
date=datetime.date(2015, 3, 26),
status=BankTransactionScheduler.STATUS_INACTIVE,
type=BankTransactionScheduler.TYPE_WEEKLY,
recurrence=None,
last_action=timezone.make_aware(datetime.datetime(2015, 1, 31,
10)),
state=BankTransactionScheduler.STATE_FINISHED,
)
bts.clone()
bt_clone = BankTransaction.objects.order_by('pk').last()
self.assertEqual(
bt_clone.date,
datetime.date(2015, 4, 2),
)
# Clone inactive doesn't alter bank account balance.
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('20.46'))
self.assertEqual(bts.date, datetime.date(2015, 4, 2))
self.assertNotEqual(
bts.last_action,
timezone.make_aware(
datetime.datetime.strptime(
'2015-03-26 03:50:00',
'%Y-%m-%d %H:%M:%S',
)))
self.assertIsNone(bts.recurrence)
self.assertEqual(bts.state, BankTransactionScheduler.STATE_FINISHED)
# Clone it again
bts.clone()
bts.refresh_from_db()
self.assertEqual(bts.date, datetime.date(2015, 4, 9))
