def test_group_members(self):
group = GroupFactory()
assert group.members.count() == 0
user1 = UserFactory()
user2 = UserFactory()
group.members.add(user1, user2)
assert group.members.count() == 2
group.members.add(user1)
assert group.members.count() == 2
group.members.remove(user1)
assert group.members.count() == 1
def test_create_bulk_transactions_may_do_it(self):
user = UserFactory()
url = reverse('transaction-list')
request_body = [
{
"reference": "000001",
"account": "S55555",
"date": "2020-01-01",
"amount": "21.13",
"type": "inflow",
"category": "transfer",
"user_id": user.id
},
{
"reference": "000002",
"account": "S55555",
"date": "2020-01-01",
"amount": "-21.13",
"type": "outflow",
"category": "payment",
"user_id": user.id
}
]
response = self.client.post(url, request_body, format='json')
expected_response = request_body
self.assertEquals(status.HTTP_201_CREATED, response.status_code)
self.assertEquals(expected_response, response.data)
def test_authenticated(self, user: User, rf: RequestFactory):
request = rf.get("/fake-url/")
request.user = UserFactory()
response = user_detail_view(request, username=user.username)
assert response.status_code == 200
def test_group_members(self):
response = self.client.get(self.detail_url)
assert response.status_code == status.HTTP_200_OK
assert response.json()['members_list'] == []
members_ids = [UserFactory().id, UserFactory().id]
response = self.client.patch(
self.detail_url, {'members': members_ids}
)
assert response.status_code == status.HTTP_200_OK
response = self.client.get(self.detail_url)
assert response.status_code == status.HTTP_200_OK
assert (
set(m['id'] for m in response.json()['members_list'])
== set(members_ids)
)
def test_calculate_balance_may_do_it_properly(self):
user = UserFactory()
account_1 = '00001'
inflow_transaction_1_account_1 = TransactionFactory(
type=Transaction.INFLOW, account=account_1, user=user)
inflow_transaction_2_account_1 = TransactionFactory(
type=Transaction.INFLOW, account=account_1, user=user)
outflow_transaction_1_account_1 = TransactionFactory(
type=Transaction.OUTFLOW, account=account_1, user=user)
outflow_transaction_2_account_1 = TransactionFactory(
type=Transaction.OUTFLOW, account=account_1, user=user)
total_inflow_account_1 = round(
Decimal(inflow_transaction_1_account_1.amount +
inflow_transaction_2_account_1.amount), 2)
total_outflow_account_1 = round(
Decimal(outflow_transaction_1_account_1.amount +
outflow_transaction_2_account_1.amount), 2)
balance_account_1 = round(
Decimal(total_inflow_account_1 + total_outflow_account_1), 2)
account_2 = '00002'
inflow_transaction_1_account_2 = TransactionFactory(
type=Transaction.INFLOW, account=account_2, user=user)
inflow_transaction_2_account_2 = TransactionFactory(
type=Transaction.INFLOW, account=account_2, user=user)
outflow_transaction_1_account_2 = TransactionFactory(
type=Transaction.OUTFLOW, account=account_2, user=user)
outflow_transaction_2_account_2 = TransactionFactory(
type=Transaction.OUTFLOW, account=account_2, user=user)
total_inflow_account_2 = round(
Decimal(inflow_transaction_1_account_2.amount +
inflow_transaction_2_account_2.amount), 2)
total_outflow_account_2 = round(
Decimal(outflow_transaction_1_account_2.amount +
outflow_transaction_2_account_2.amount), 2)
balance_account_2 = round(
Decimal(total_inflow_account_2 + total_outflow_account_2), 2)
transactions = Transaction.objects.filter(user=user)
queryset = TransactionService.calculate_balance(transactions)
expected_account_1 = {
'account': '00001',
'total_inflow': total_inflow_account_1,
'total_outflow': total_outflow_account_1,
'balance': balance_account_1
}
expected_account_2 = {
'account': '00002',
'total_inflow': total_inflow_account_2,
'total_outflow': total_outflow_account_2,
'balance': balance_account_2
}
self.assertEquals(expected_account_1, queryset[0])
self.assertEquals(expected_account_2, queryset[1])
def test_get_balance_of_user_may_do_it_properly(self):
user = UserFactory()
TransactionFactory.create_batch(3, user=user)
url = reverse('transaction-detail', kwargs={'user_id': user.id})
response = self.client.get(url)
transaction_number = Transaction.objects.filter(user=user).count()
self.assertEquals(status.HTTP_200_OK, response.status_code)
self.assertEquals(transaction_number, len(response.data['results']))
def test_calculate_summary_may_do_it_properly(self):
user = UserFactory()
TransactionFactory.create_batch(5, user=user)
summary = TransactionService.calculate_summary(user.id)
self.assertIsInstance(summary, dict)
self.assertIn('inflow', summary)
self.assertIsInstance(summary['inflow'], dict)
self.assertIn('outflow', summary)
self.assertIsInstance(summary['outflow'], dict)
def user(request):
"""Pytest setup for user model."""
management.call_command('load_user_types')
def fin():
print("teardown")
User.objects.all().delete()
UserType.objects.all().delete()
request.addfinalizer(fin)
return UserFactory()
def test_get_user_summary_may_do_it_properly(self):
user = UserFactory()
TransactionFactory.create_batch(5, user=user)
url = reverse('transaction-summary', kwargs={'user_id': user.id})
response = self.client.get(url)
self.assertEquals(status.HTTP_200_OK, response.status_code)
self.assertIsInstance(response.data, dict)
self.assertIn('inflow', response.data)
self.assertIsInstance(response.data['inflow'], dict)
self.assertIn('outflow', response.data)
self.assertIsInstance(response.data['outflow'], dict)
def test_user_detail_when_user_exists_returns_its_data(self):
user = UserFactory()
url = reverse('user-detail', kwargs={'pk': user.id})
response = self.client.get(url)
expected_response = {
'id': user.id,
'name': user.name,
'email': user.email,
'age': user.age
}
self.assertEquals(status.HTTP_200_OK, response.status_code)
self.assertEquals(expected_response, response.data)
def test_user_groups(self):
user = UserFactory()
assert user.groups.count() == 0
group1 = GroupFactory()
group2 = GroupFactory()
user.groups.add(group1, group2)
assert user.groups.count() == 2
user.groups.add(group1)
assert user.groups.count() == 2
user.groups.remove(group1)
assert user.groups.count() == 1
def test_create_user_with_existing_email_returns_error(self):
user = UserFactory()
url = reverse('user-list')
request_body = {"name": "Batman", "email": user.email, "age": 27}
response = self.client.post(url, request_body)
expected_response = {
'email': [
'user with this Email address already exists.',
'Enter a valid email address.'
]
}
self.assertEquals(status.HTTP_400_BAD_REQUEST, response.status_code)
self.assertEquals(expected_response, response.data)
def test_get_balance_of_user_filtered_by_after_date_may_do_it_properly(self):
user = UserFactory()
date_1 = '2020-01-01'
date_2 = '2020-10-01'
TransactionFactory.create_batch(3, user=user, date=date_1)
TransactionFactory.create_batch(4, user=user, date=date_2)
url = reverse('transaction-detail', kwargs={'user_id': user.id})
date_after = '2020-09-01'
url_with_filter = f'{url}?date_after={date_after}'
response = self.client.get(url_with_filter)
transaction_number = Transaction.objects.filter(user=user, date__gt=date_after).count()
self.assertEquals(status.HTTP_200_OK, response.status_code)
self.assertEquals(transaction_number, len(response.data['results']))
def test_create_outflow_transaction_with_positive_amount_returns_error(self):
user = UserFactory()
url = reverse('transaction-list')
request_body = {
"reference": "000001",
"account": "S55555",
"date": "2020-01-01",
"amount": "21.13",
"type": "outflow",
"category": "payment",
"user_id": user.id
}
response = self.client.post(url, request_body)
expected_response = {'amount': ['Amount must be negative']}
self.assertEquals(status.HTTP_400_BAD_REQUEST, response.status_code)
self.assertEquals(expected_response, response.json())
def test_new_user(self):
"""Tests new user creation."""
user = UserFactory()
assert user.groups.count() == 0
def user() -> User:
"""Pytest setup for user model."""
return UserFactory()
def test_email_duplicates(self):
"""Tests duplicate emails."""
user = UserFactory()
with pytest.raises(IntegrityError):
UserFactory(email=user.email)
def test_state_validation(self):
"""Tests state verification."""
user = UserFactory(state='wrong_state')
with pytest.raises(ValidationError):
user.full_clean()
def test_email_validation(self):
"""Tests email verification."""
user = UserFactory(email='invalid_email')
with pytest.raises(ValidationError):
user.full_clean()
def _existing_user(cls):
user = UserFactory()
cls.existing_user = user
cls.detail_url = reverse('user-detail', args=[user.id])
def test_case_sensitivity(self, rf: RequestFactory):
request = rf.get("/fake-url/")
request.user = UserFactory(username="******")
with pytest.raises(Http404):
user_detail_view(request, username="******")
def user() -> User:
return UserFactory()
def user() -> settings.AUTH_USER_MODEL:
"""Pytest setup for user model."""
return UserFactory()