def test_extra(self):
user = UserFactory(user_permissions='admin')
bankaccount = BankAccountFactory(owners=[user])
BankAccountFactory()
response = self.client.get(reverse('home'), follow=True)
self.assertNotIn('user_bankaccounts', response.context[0])
self.client.force_login(user)
response = self.client.get(reverse('home'), follow=True)
self.assertListEqual(
[ba.pk for ba in response.context[0]['user_bankaccounts']],
[bankaccount.pk],
)
mymoney_settings = settings.MYMONEY.copy()
mymoney_settings['USE_L10N_DIST'] = False
with self.settings(MYMONEY=mymoney_settings, LANGUAGE_CODE='en-us'):
response = self.client.get(reverse('home'), follow=True)
self.assertNotIn('.min.en-US.js',
response.context[0]['dist_js_src'])
mymoney_settings = settings.MYMONEY.copy()
mymoney_settings['USE_L10N_DIST'] = True
with self.settings(MYMONEY=mymoney_settings, LANGUAGE_CODE='en-us'):
response = self.client.get(reverse('home'), follow=True)
self.assertIn('.min.en-US.js', response.context[0]['dist_js_src'])
mymoney_settings = settings.MYMONEY.copy()
mymoney_settings['USE_L10N_DIST'] = True
with self.settings(MYMONEY=mymoney_settings, LANGUAGE_CODE='fr-fr'):
response = self.client.get(reverse('home'), follow=True)
self.assertIn('.min.fr-FR.js', response.context[0]['dist_js_src'])
def test_status_disabled(self):
# Test with create op.
bankaccount = BankAccountFactory(balance=100)
BankTransactionFactory(bankaccount=bankaccount,
amount=Decimal('150'),
status=BankTransaction.STATUS_INACTIVE)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(100))
# Then test with update.
banktransaction = BankTransactionFactory(
bankaccount=bankaccount,
amount=Decimal('150'),
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('250'))
banktransaction.status = BankTransaction.STATUS_INACTIVE
banktransaction.amount = Decimal('180')
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('250'))
# Then test with delete op.
banktransaction.delete()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('250'))
def test_redirect_authenticated_multiple_bankaccounts(self):
user = UserFactory()
BankAccountFactory(owners=[user])
BankAccountFactory(owners=[user])
self.client.force_login(user)
response = self.client.get(self.url, follow=True)
self.assertEqual(response.resolver_match.view_name, 'bankaccounts:list')
def test_action_delete(self):
bankaccount = BankAccountFactory(owners=[self.superowner])
url = reverse('banktransactions:list',
kwargs={'bankaccount_pk': bankaccount.pk})
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
amount='5.59',
)
bt2 = BankTransactionFactory(
bankaccount=bankaccount,
amount='-15.59',
)
bt3 = BankTransactionFactory(
bankaccount=bankaccount,
amount='75',
)
balance = bankaccount.balance
form = self.app.get(url, user='******').form
for bt in [bt1, bt2, bt3]:
form['banktransaction_' + str(bt.pk)] = True
form['operation'] = 'delete'
response = form.submit('action').maybe_follow()
# Test cancel link
response = response.click(description=_("Cancel"))
self.assertEqual(
response.request.path,
reverse('banktransactions:list',
kwargs={
'bankaccount_pk': bankaccount.pk,
}))
# Is delete somewhere else.
bt3.delete()
balance -= Decimal(75)
# Direct access on multiple delete page. Session is not up-to-date.
form = self.app.get(
reverse('banktransactions:delete_multiple',
kwargs={'bankaccount_pk': bankaccount.pk})).form
response = form.submit().maybe_follow()
self.assertFalse(
list(BankTransaction.objects.filter(pk__in=[bt1.pk, bt2.pk])))
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance,
balance - Decimal('5.59') - Decimal('-15.59'))
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transactions deleted successfully.',
[message.message for message in storage],
)
def test_banktransaction_insert_fail(self):
bankaccount = BankAccountFactory(balance=0)
with patch.object(BankTransaction, "save", side_effect=Exception("Bang")):
with self.assertRaises(Exception):
BankTransactionFactory(bankaccount=bankaccount, amount="15.59")
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, 0)
def test_delete(self):
bankaccount = BankAccountFactory(balance=50)
banktransaction = BankTransactionFactory(bankaccount=bankaccount, amount="-25")
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(25))
banktransaction.delete()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(50))
def test_delete_bankaccount(self):
bankaccount = BankAccountFactory()
BankTransactionSchedulerFactory.create_batch(5)
bankaccount_pk = bankaccount.pk
bankaccount.delete()
self.assertEqual(
BankTransactionScheduler.objects.filter(bankaccount__pk=bankaccount_pk).count(),
0,
)
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_bankaccount_update_fail(self):
bankaccount = BankAccountFactory(balance=0)
with patch.object(BankAccount, 'save', side_effect=Exception('Bang')):
with self.assertRaises(Exception):
BankTransactionFactory(
bankaccount=bankaccount,
amount='15.59',
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, 0)
def test_delete_bankaccount(self):
bankaccount = BankAccountFactory()
BankTransactionSchedulerFactory.create_batch(5)
bankaccount_pk = bankaccount.pk
bankaccount.delete()
self.assertEqual(
BankTransactionScheduler.objects.filter(
bankaccount__pk=bankaccount_pk).count(),
0,
)
def test_banktransaction_update_fail(self):
bankaccount = BankAccountFactory(balance=0)
banktransaction = BankTransactionFactory(bankaccount=bankaccount, amount="-10")
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(-10))
with patch.object(BankTransaction, "save", side_effect=Exception("Bang")):
with self.assertRaises(Exception):
banktransaction.amount = -50
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(-10))
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_context_data(self):
bankaccount = BankAccountFactory(owners=[self.owner, self.superowner])
banktransaction = BankTransactionFactory(bankaccount=bankaccount)
url = reverse('banktransactions:calendar_ajax_event',
kwargs={
'pk': banktransaction.pk,
})
response = self.app.get(url, user='******')
self.assertEqual(
response.context['banktransaction'].pk,
banktransaction.pk,
)
self.assertNotIn('edit_url', response.context)
self.assertNotIn('delete_url', response.context)
response = self.app.get(url, user='******')
self.assertEqual(
response.context['banktransaction'].pk,
banktransaction.pk,
)
self.assertEqual(
response.context['url_edit'],
reverse('banktransactions:update',
kwargs={'pk': banktransaction.pk}))
self.assertEqual(
response.context['url_delete'],
reverse('banktransactions:delete',
kwargs={'pk': banktransaction.pk}))
def test_action_unreconcile(self):
bankaccount = BankAccountFactory(owners=[self.superowner])
url = reverse('banktransactions:list',
kwargs={'bankaccount_pk': bankaccount.pk})
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
amount='5.59',
reconciled=True,
)
bt2 = BankTransactionFactory(
bankaccount=bankaccount,
amount='-15.59',
reconciled=True,
)
form = self.app.get(url, user='******').form
for bt in [bt1, bt2]:
form['banktransaction_' + str(bt.pk)] = True
form['operation'] = 'unreconcile'
response = form.submit('action').maybe_follow()
for bt in [bt1, bt2]:
bt.refresh_from_db()
self.assertFalse(bt.reconciled)
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Undo bank transaction reconciled.',
[message.message for message in storage],
)
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_clone_queryset_update_failed(self, update_mock):
update_mock.side_effect = Exception('Click-click Booom!')
bankaccount = BankAccountFactory(balance=0)
bts = BankTransactionSchedulerFactory(
bankaccount=bankaccount,
recurrence=None,
state=BankTransactionScheduler.STATE_WAITING,
last_action=None,
)
with patch.object(BankTransactionScheduler,
'save',
side_effect=Exception('Click-click Booom!')):
with self.assertLogs(
logger='mymoney.apps.banktransactionschedulers.models',
level='ERROR'):
bts.clone()
bts.refresh_from_db()
self.assertEqual(bts.state, BankTransactionScheduler.STATE_WAITING)
self.assertEqual(
BankTransaction.objects.filter(bankaccount=bankaccount).count(),
0,
)
def test_save_success(self):
bankaccount = BankAccountFactory(balance=-10)
# Test insert.
banktransaction = BankTransactionFactory(bankaccount=bankaccount, amount="15.59")
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal("5.59"))
# Then test update.
banktransaction.refresh_from_db()
banktransaction.amount += Decimal("14.41")
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal("20"))
def test_default_value_localize(self):
bankaccount = BankAccountFactory(owners=[self.owner])
url = reverse('banktransactions:list',
kwargs={'bankaccount_pk': bankaccount.pk})
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
date=datetime.date(2015, 5, 11),
amount="15.59",
)
bt2 = BankTransactionFactory( # noqa
bankaccount=bankaccount,
date=datetime.date(2015, 5, 12),
amount="-25.59",
)
form = self.app.get(url, user='******').form
fields = {
'date_start': '11/05/2015',
'date_end': '11/05/2015',
}
for name, value in fields.items():
form[name] = value
response = form.submit('filter').maybe_follow()
form = response.form
self.assertEqual(
fields['date_start'],
form['date_start'].value,
)
self.assertEqual(
fields['date_end'],
form['date_end'].value,
)
self.assertListEqual(
response.context[0].get('object_list', []),
[bt1],
)
response = form.submit('reset').maybe_follow()
form = response.form
fields = {
'amount_min': '10,26',
'amount_max': '20,5',
}
for name, value in fields.items():
form[name] = value
response = form.submit('filter').maybe_follow()
form = response.form
self.assertEqual(fields['amount_min'], form['amount_min'].value)
self.assertEqual(fields['amount_max'], form['amount_max'].value)
self.assertListEqual(
response.context[0].get('object_list', []),
[bt1],
)
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 setUpTestData(cls):
cls.owner = UserFactory(username='******')
cls.not_owner = UserFactory(username='******',
user_permissions='staff')
cls.superowner = UserFactory(username='******',
user_permissions='admin')
cls.bankaccount = BankAccountFactory(
owners=[cls.owner, cls.superowner])
def test_reconciled_balance(self):
bankaccount = BankAccountFactory(balance=0)
self.assertEqual(
BankTransaction.objects.get_reconciled_balance(bankaccount),
0,
)
# Not reconciled by default.
BankTransactionFactory(
bankaccount=bankaccount,
amount=-15,
)
self.assertEqual(
BankTransaction.objects.get_reconciled_balance(bankaccount),
0,
)
# Should work.
BankTransactionFactory(
bankaccount=bankaccount,
amount=40,
reconciled=True,
)
self.assertEqual(
BankTransaction.objects.get_reconciled_balance(bankaccount),
Decimal(40),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount=-30,
reconciled=True,
)
BankTransactionFactory(
bankaccount=bankaccount,
amount=55,
)
# Inactive, don't use it.
BankTransactionFactory(
bankaccount=bankaccount,
amount=-150,
reconciled=True,
status=BankTransaction.STATUS_INACTIVE,
)
# Ignored is not inactive, so use it.
BankTransactionFactory(
bankaccount=bankaccount,
amount=-5,
reconciled=True,
status=BankTransaction.STATUS_IGNORED,
)
self.assertEqual(
BankTransaction.objects.get_reconciled_balance(bankaccount),
Decimal(5),
)
def setUpTestData(cls):
cls.owner = UserFactory(username='******')
cls.superowner = UserFactory(username='******',
user_permissions='admin')
cls.bankaccount = BankAccountFactory(
owners=[cls.owner, cls.superowner],
balance_initial=Decimal('10.15'),
)
cls.banktransaction = BankTransactionFactory(
bankaccount=cls.bankaccount)
def test_current_balance(self):
bankaccount = BankAccountFactory(balance=0)
self.assertEqual(
BankTransaction.objects.get_current_balance(bankaccount),
0,
)
BankTransactionFactory(
bankaccount=bankaccount,
amount=-15,
date=datetime.date.today() - datetime.timedelta(5),
)
# Ignored for stat only, so used here.
BankTransactionFactory(
bankaccount=bankaccount,
amount=10,
date=datetime.date.today() - datetime.timedelta(7),
status=BankTransaction.STATUS_IGNORED,
)
# Next, so not used.
BankTransactionFactory(
bankaccount=bankaccount,
amount=40,
date=datetime.date.today() + datetime.timedelta(5),
)
# Inactive, don't use it.
BankTransactionFactory(
bankaccount=bankaccount,
amount=40,
date=datetime.date.today() - datetime.timedelta(5),
status=BankTransaction.STATUS_INACTIVE,
)
self.assertEqual(
BankTransaction.objects.get_current_balance(bankaccount),
Decimal(-5),
)
# Try it again with new records.
BankTransactionFactory(
bankaccount=bankaccount,
amount=-30,
date=datetime.date.today() - datetime.timedelta(5),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount=55,
date=datetime.date.today() + datetime.timedelta(5),
)
self.assertEqual(
BankTransaction.objects.get_current_balance(bankaccount),
Decimal(-35),
)
def test_get_user_tags_with_bankaccount(self):
superowner = UserFactory(username='******',
user_permissions='admin')
banktransactiontag = BankTransactionTagFactory(owner=superowner)
BankAccountFactory(owners=[self.owner, superowner])
tags = BankTransactionTag.objects.get_user_tags_queryset(self.owner)
self.assertListEqual([
self.banktransactiontags[0].pk,
banktransactiontag.pk,
], sorted([tag.pk for tag in tags]))
def test_redirect_authenticated_one_bankaccount(self):
user = UserFactory()
bankaccount = BankAccountFactory(owners=[user])
self.client.force_login(user)
response = self.client.get(self.url, follow=True)
self.assertEqual(response.resolver_match.view_name, 'banktransactions:list')
self.assertDictEqual(response.resolver_match.kwargs, {
'bankaccount_pk': str(bankaccount.pk),
})
def test_force_currency(self):
bankaccount = BankAccountFactory(currency='EUR')
banktransaction = BankTransactionFactory(
bankaccount=bankaccount,
currency='USD',
)
self.assertEqual(banktransaction.currency, 'EUR')
banktransaction.currency = 'USD'
banktransaction.save()
self.assertEqual(banktransaction.currency, 'EUR')
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_clone_delete_failed(self, delete_mock):
delete_mock.side_effect = Exception('Click-click boom!')
bankaccount = BankAccountFactory(balance=0)
bts = BankTransactionSchedulerFactory(
bankaccount=bankaccount,
recurrence=1,
)
with self.assertLogs(
logger='mymoney.apps.banktransactionschedulers.models',
level='ERROR'):
bts.clone()
bts.refresh_from_db()
self.assertEqual(bts.state, BankTransactionScheduler.STATE_FAILED)
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']]
)
def test_status_disabled(self):
# Test with create op.
bankaccount = BankAccountFactory(balance=100)
BankTransactionFactory(bankaccount=bankaccount, amount=Decimal("150"), status=BankTransaction.STATUS_INACTIVE)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(100))
# Then test with update.
banktransaction = BankTransactionFactory(bankaccount=bankaccount, amount=Decimal("150"))
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal("250"))
banktransaction.status = BankTransaction.STATUS_INACTIVE
banktransaction.amount = Decimal("180")
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal("250"))
# Then test with delete op.
banktransaction.delete()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal("250"))
def test_delete(self):
bankaccount = BankAccountFactory(balance=50)
banktransaction = BankTransactionFactory(
bankaccount=bankaccount,
amount='-25',
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(25))
banktransaction.delete()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(50))
def test_clone_insert_failed(self, save_mock):
save_mock.side_effect = Exception('Click-click boom!')
bankaccount = BankAccountFactory(balance=0)
bts = BankTransactionSchedulerFactory(
bankaccount=bankaccount,
recurrence=5,
date=datetime.date(2015, 7, 10),
last_action=None,
state=BankTransactionScheduler.STATE_WAITING,
)
with self.assertLogs(
logger='mymoney.apps.banktransactionschedulers.models',
level='ERROR'):
bts.clone()
bts.refresh_from_db()
self.assertEqual(bts.state, BankTransactionScheduler.STATE_FAILED)
self.assertEqual(bts.date, datetime.date(2015, 7, 10))
self.assertEqual(bts.recurrence, 5)
self.assertIsNone(bts.last_action)
def test_banktransaction_update_fail(self):
bankaccount = BankAccountFactory(balance=0)
banktransaction = BankTransactionFactory(
bankaccount=bankaccount,
amount='-10',
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(-10))
with patch.object(BankTransaction, 'save', side_effect=Exception('Bang')):
with self.assertRaises(Exception):
banktransaction.amount = -50
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(-10))
def test_save_success(self):
bankaccount = BankAccountFactory(balance=-10)
# Test insert.
banktransaction = BankTransactionFactory(
bankaccount=bankaccount,
amount='15.59',
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('5.59'))
# Then test update.
banktransaction.refresh_from_db()
banktransaction.amount += Decimal('14.41')
banktransaction.save()
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('20'))
def test_total_balance(self):
bankaccount = BankAccountFactory(balance=0, owners=[self.superowner])
url = reverse('banktransactions:list', kwargs={
'bankaccount_pk': bankaccount.pk
})
BankTransactionFactory(
bankaccount=bankaccount,
amount='-15.59',
date=datetime.date(2015, 6, 3),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount='-4.41',
date=datetime.date(2015, 6, 3),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount='5.00',
date=datetime.date(2015, 6, 3),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount='5.59',
date=datetime.date(2015, 6, 4),
)
BankTransactionFactory(
bankaccount=bankaccount,
amount='6.59',
date=datetime.date(2015, 6, 4),
)
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal('-2.82'))
response = self.app.get(url, user='******')
object_list = list(reversed(response.context[0].get('object_list')))
self.assertListEqual(
[obj.total_balance for obj in object_list],
[
Decimal('-15.59'),
Decimal('-20'),
Decimal('-15'),
Decimal('-9.41'),
Decimal('-2.82'),
],
)
bankaccount.balance_initial = Decimal('150')
bankaccount.save()
response = self.app.get(url, user='******')
object_list = list(reversed(response.context[0].get('object_list')))
self.assertListEqual(
[obj.total_balance for obj in object_list],
[
Decimal('150') + Decimal('-15.59'),
Decimal('150') + Decimal('-20'),
Decimal('150') + Decimal('-15'),
Decimal('150') + Decimal('-9.41'),
Decimal('150') + Decimal('-2.82'),
],
)
def test_reconciled_balance(self):
bankaccount = BankAccountFactory(balance=0, owners=[self.superowner])
url = reverse('banktransactions:list', kwargs={
'bankaccount_pk': bankaccount.pk
})
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
amount='-15.59',
date=datetime.date(2015, 6, 3),
)
bt2 = BankTransactionFactory(
bankaccount=bankaccount,
amount='-4.41',
reconciled=True,
date=datetime.date(2015, 6, 3),
)
bt3 = BankTransactionFactory(
bankaccount=bankaccount,
amount='5.00',
reconciled=True,
date=datetime.date(2015, 6, 3),
)
bt4 = BankTransactionFactory(
bankaccount=bankaccount,
amount='5.59',
date=datetime.date(2015, 6, 4),
)
bt5 = BankTransactionFactory(
bankaccount=bankaccount,
amount='6.59',
reconciled=True,
date=datetime.date(2015, 6, 4),
)
response = self.app.get(url, user='******')
object_list = list(reversed(response.context[0].get('object_list')))
self.assertListEqual(
[obj.pk for obj in object_list],
[bt1.pk, bt2.pk, bt3.pk, bt4.pk, bt5.pk],
)
self.assertListEqual(
[obj.reconciled_balance for obj in object_list],
[
# None, which should be balance initial instead. But this is
# done in the template to prevent useless queryset loop just
# for this special use case.
None,
Decimal('-4.41'), # First reconciled bank transaction.
Decimal('0.59'), # -4.41 + 5
Decimal('0.59'), # Not reconciled, so previous value: 0.59
Decimal('7.18'), # 0.59 + 6.59
],
)
bankaccount.balance_initial = Decimal('150')
bankaccount.save()
response = self.app.get(url, user='******')
object_list = list(reversed(response.context[0].get('object_list')))
self.assertListEqual(
[obj.reconciled_balance for obj in object_list],
[
None,
Decimal('150') + Decimal('-4.41'),
Decimal('150') + Decimal('0.59'),
Decimal('150') + Decimal('0.59'),
Decimal('150') + Decimal('7.18'),
],
)
def test_action_delete(self):
bankaccount = BankAccountFactory(owners=[self.superowner])
url = reverse('banktransactions:list', kwargs={
'bankaccount_pk': bankaccount.pk
})
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
amount='5.59',
)
bt2 = BankTransactionFactory(
bankaccount=bankaccount,
amount='-15.59',
)
bt3 = BankTransactionFactory(
bankaccount=bankaccount,
amount='75',
)
balance = bankaccount.balance
form = self.app.get(url, user='******').form
for bt in [bt1, bt2, bt3]:
form['banktransaction_' + str(bt.pk)] = True
form['operation'] = 'delete'
response = form.submit('action').maybe_follow()
# Test cancel link
response = response.click(description=_("Cancel"))
self.assertEqual(
response.request.path,
reverse('banktransactions:list', kwargs={
'bankaccount_pk': bankaccount.pk,
})
)
# Is delete somewhere else.
bt3.delete()
balance -= Decimal(75)
# Direct access on multiple delete page. Session is not up-to-date.
form = self.app.get(
reverse('banktransactions:delete_multiple', kwargs={
'bankaccount_pk': bankaccount.pk
})
).form
response = form.submit().maybe_follow()
self.assertFalse(
list(BankTransaction.objects.filter(pk__in=[bt1.pk, bt2.pk]))
)
bankaccount.refresh_from_db()
self.assertEqual(
bankaccount.balance,
balance - Decimal('5.59') - Decimal('-15.59')
)
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transactions deleted successfully.',
[message.message for message in storage],
)
def test_scheduler(self):
bankaccount = BankAccountFactory(balance=0)
BankTransactionSchedulerFactory(
amount=Decimal(10),
bankaccount=bankaccount,
date="2015-01-31",
last_action=None,
state=BankTransactionScheduler.STATE_WAITING,
)
BankTransactionSchedulerFactory(
amount=Decimal(20),
bankaccount=bankaccount,
date="2015-01-31",
type="monthly",
recurrence="2",
last_action=None,
state=BankTransactionScheduler.STATE_WAITING,
)
BankTransactionSchedulerFactory(
amount=Decimal(-5),
bankaccount=bankaccount,
date="2015-03-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,
)
BankTransactionSchedulerFactory(
amount=Decimal(10),
bankaccount=bankaccount,
date="2015-01-31",
last_action=timezone.now() + datetime.timedelta(days=100),
state=BankTransactionScheduler.STATE_FINISHED,
)
# Clone two first scheduled.
out = StringIO()
call_command('clonescheduled', limit=2, stdout=out)
self.assertIn('Scheduled bank transaction have been cloned.', out.getvalue())
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(30))
self.assertEqual(
BankTransaction.objects.filter(bankaccount=bankaccount).count(),
2,
)
# Clone latest.
call_command('clonescheduled', stdout=StringIO())
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(30))
self.assertEqual(
BankTransaction.objects.filter(bankaccount=bankaccount).count(),
3,
)
# Nothing happen.
call_command('clonescheduled', stdout=StringIO())
bankaccount.refresh_from_db()
self.assertEqual(bankaccount.balance, Decimal(30))
self.assertEqual(
BankTransaction.objects.filter(bankaccount=bankaccount).count(),
3,
)
def setUp(self):
self.bankaccount = BankAccountFactory(balance=0, owners=[self.superowner])
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))
def setUp(self):
for bankaccount in BankAccount.objects.all():
bankaccount.delete()
self.bankaccount = BankAccountFactory(balance=0)
class ManagerTestCase(unittest.TestCase):
def setUp(self):
for bankaccount in BankAccount.objects.all():
bankaccount.delete()
self.bankaccount = BankAccountFactory(balance=0)
def tearDown(self):
self.bankaccount.delete()
def test_awaiting_bank_transactions(self):
# Waiting, should be good.
bts1 = BankTransactionSchedulerFactory(
amount=Decimal('0'),
bankaccount=self.bankaccount,
type=BankTransactionScheduler.TYPE_MONTHLY,
state=BankTransactionScheduler.STATE_WAITING,
last_action=None,
)
# Finished, but need to be reroll.
bts2 = BankTransactionSchedulerFactory(
amount=Decimal('0'),
bankaccount=self.bankaccount,
type=BankTransactionScheduler.TYPE_MONTHLY,
state=BankTransactionScheduler.STATE_FINISHED,
last_action=timezone.make_aware(datetime.datetime(2015, 5, 19, 15)),
)
# Finished, but need to be reroll.
bts3 = BankTransactionSchedulerFactory(
amount=Decimal('0'),
bankaccount=self.bankaccount,
type=BankTransactionScheduler.TYPE_WEEKLY,
state=BankTransactionScheduler.STATE_FINISHED,
last_action=timezone.make_aware(datetime.datetime(2015, 5, 19, 15)),
)
# Failed, do nothing.
bts4 = BankTransactionSchedulerFactory( # noqa
amount=Decimal('0'),
bankaccount=self.bankaccount,
type=BankTransactionScheduler.TYPE_MONTHLY,
state=BankTransactionScheduler.STATE_FAILED,
last_action=None,
)
# Month and week
with patch('django.utils.timezone.now'):
timezone.now.return_value = timezone.make_aware(
datetime.datetime(2015, 6, 2, 15),
)
qs = BankTransactionScheduler.objects.get_awaiting_banktransactions()
qs = qs.order_by('pk')
self.assertListEqual(
[obj.pk for obj in qs],
[bts1.pk, bts2.pk, bts3.pk],
)
# Week only.
with patch('django.utils.timezone.now'):
timezone.now.return_value = timezone.make_aware(
datetime.datetime(2015, 5, 26, 15),
)
qs = BankTransactionScheduler.objects.get_awaiting_banktransactions()
qs = qs.order_by('pk')
self.assertListEqual(
[obj.pk for obj in qs],
[bts1.pk, bts3.pk],
)
# None of both.
with patch('django.utils.timezone.now'):
timezone.now.return_value = timezone.make_aware(
datetime.datetime(2015, 5, 20),
)
qs = BankTransactionScheduler.objects.get_awaiting_banktransactions()
qs = qs.order_by('pk')
self.assertListEqual(
[obj.pk for obj in qs],
[bts1.pk],
)
def test_total_debit(self):
total = BankTransactionScheduler.objects.get_total_debit(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_debit(self.bankaccount)
self.assertDictEqual(total, {
BankTransactionScheduler.TYPE_MONTHLY: Decimal(-45),
BankTransactionScheduler.TYPE_WEEKLY: Decimal(-5),
})
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),
})
def setUp(self):
self.bankaccount = BankAccountFactory(
owners=[self.owner, self.superowner])
def test_total_unscheduled_period(self):
bankaccount = BankAccountFactory(balance=0)
bt1 = BankTransactionFactory(
bankaccount=bankaccount,
amount=Decimal('-152.23'),
date=datetime.date(2015, 8, 9),
)
bt2 = BankTransactionFactory(
bankaccount=bankaccount,
amount=Decimal('2347.78'),
date=datetime.date(2015, 8, 13),
)
bt3 = BankTransactionFactory(
bankaccount=bankaccount,
amount=Decimal('-561.78'),
date=datetime.date(2015, 8, 16),
)
# Out-of-date.
bt4 = BankTransactionFactory( # noqa
bankaccount=bankaccount,
date=datetime.date(2015, 9, 15),
amount=Decimal('-10000'),
)
# Scheduled.
bt5 = BankTransactionFactory( # noqa
bankaccount=bankaccount,
scheduled=True,
amount=Decimal('-10000'),
date=datetime.date(2015, 8, 16),
)
# Inactive.
bt6 = BankTransactionFactory( # noqa
bankaccount=bankaccount,
status=BankTransaction.STATUS_INACTIVE,
amount=Decimal('-10000'),
date=datetime.date(2015, 8, 16),
)
# An another bank account.
bt7 = BankTransactionFactory( # noqa
bankaccount=BankAccountFactory(),
amount=Decimal('-10000'),
date=datetime.date(2015, 8, 16),
)
with patch('mymoney.apps.banktransactions.models.get_date_ranges',
return_value=(
datetime.date(2015, 8, 1),
datetime.date(2015, 8, 30),
)):
total = BankTransaction.objects.get_total_unscheduled_period(
bankaccount, GRANULARITY_MONTH)
self.assertEqual(
total,
bt1.amount + bt2.amount + bt3.amount,
)
with patch('mymoney.apps.banktransactions.models.get_date_ranges',
return_value=(
datetime.date(2015, 8, 9),
datetime.date(2015, 8, 15),
)):
total = BankTransaction.objects.get_total_unscheduled_period(
bankaccount,
GRANULARITY_WEEK,
)
self.assertEqual(
total,
bt1.amount + bt2.amount,
)
def setUpTestData(cls):
cls.owner = UserFactory(username='******')
cls.bankaccount = BankAccountFactory(owners=[cls.owner])
class FormTestCase(WebTest):
@classmethod
def setUpTestData(cls):
cls.superowner = UserFactory(username='******', user_permissions='admin')
def setUp(self):
self.bankaccount = BankAccountFactory(balance=0, owners=[self.superowner])
def test_default_bankaccount(self):
url = reverse('banktransactions:create', kwargs={
'bankaccount_pk': self.bankaccount.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('bankaccount', form.fields)
edit = {
'label': 'test implicit bank account',
'amount': '0.00',
}
for name, value in edit.items():
form[name] = value
form.submit().maybe_follow()
banktransaction = BankTransaction.objects.get(label=edit['label'])
self.assertEqual(banktransaction.bankaccount.pk, self.bankaccount.pk)
url = reverse('banktransactions:update', kwargs={
'pk': banktransaction.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('bankaccount', form.fields)
edit = {
'label': 'new label',
'amount': '-10.00',
}
for name, value in edit.items():
form[name] = value
form.submit().maybe_follow()
banktransaction.refresh_from_db()
self.assertEqual(banktransaction.bankaccount.pk, self.bankaccount.pk)
@override_settings(LANGUAGE_CODE='en-us')
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']
)
@override_settings(LANGUAGE_CODE='en-us')
def test_create_form(self):
url = reverse('banktransactions:create', kwargs={
'bankaccount_pk': self.bankaccount.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('currency', form.fields)
self.assertNotIn('scheduled', form.fields)
edit = {
'label': 'test create',
'amount': '-187.41',
'memo': "OMG, I didn't remember!",
}
for name, value in edit.items():
form[name] = value
response = form.submit().maybe_follow()
banktransaction = BankTransaction.objects.get(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.assertTrue(banktransaction.date)
self.assertFalse(banktransaction.reconciled)
self.assertEqual(banktransaction.payment_method, BankTransaction.PAYMENT_METHOD_CREDIT_CARD)
self.assertEqual(banktransaction.memo, edit['memo'])
self.assertFalse(banktransaction.scheduled)
self.bankaccount.refresh_from_db()
self.assertEqual(self.bankaccount.balance, Decimal('-187.41'))
storage = messages.get_messages(response.context[0].request)
self.assertIn(
'Bank transaction %(label)s was created successfully.' % {
'label': banktransaction.label
},
[message.message for message in storage],
)
@override_settings(LANGUAGE_CODE='en-us')
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_delete_form(self):
banktransaction = BankTransactionFactory(bankaccount=self.bankaccount)
url = reverse('banktransactions:delete', kwargs={
'pk': banktransaction.pk
})
response = self.app.get(url, user='******')
response = response.click(description=_('Cancel'))
self.assertEqual(
response.request.path,
reverse('banktransactions:list', kwargs={
'bankaccount_pk': self.bankaccount.pk,
})
)
banktransaction.refresh_from_db()
response = (
self.app.get(url, user='******')
.form.submit()
.maybe_follow()
)
self.assertEqual(
response.request.path,
reverse('banktransactions:list', kwargs={
'bankaccount_pk': self.bankaccount.pk
})
)
with self.assertRaises(BankTransaction.DoesNotExist):
banktransaction.refresh_from_db()
def test_redirect_form(self):
# Check on create form.
url = reverse('banktransactions:create', kwargs={
'bankaccount_pk': self.bankaccount.pk
})
form = self.app.get(url, user='******').form
self.assertFalse(form['redirect'].checked)
edit = {
'label': 'test redirect',
'amount': '-50',
'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.
banktransaction = BankTransactionFactory(bankaccount=self.bankaccount)
url = reverse('banktransactions:update', kwargs={
'pk': banktransaction.pk
})
form = self.app.get(url, user='******').form
self.assertNotIn('redirect', form.fields)
