[WIP] Tests for kfet views

This commit is contained in:
Aurélien Delobelle 2017-08-10 15:02:08 +02:00
parent 878c617cc7
commit c9aac8a49d
3 changed files with 585 additions and 22 deletions

View file

@ -1,26 +1,243 @@
import json
from decimal import Decimal
from unittest.mock import patch
from django.test import TestCase, Client
from django.contrib.auth.models import User
from django.contrib.auth.models import Group, Permission
from django.core.urlresolvers import reverse
from django.test import Client, TestCase
from django.utils import timezone
from ..models import Account, OperationGroup, Checkout, Operation
from ..models import Account, Checkout, Operation, OperationGroup
from .testcases import ViewTestCaseMixin
from .utils import create_team, create_user
class AccountTests(TestCase):
"""Account related views"""
class LoginGenericTeamViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.login.genericteam'
url_expected = '/k-fet/login/genericteam'
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
logged_in_username = r.wsgi_request.user.username
self.assertEqual(logged_in_username, 'kfet_genericteam')
class AccountListViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account'
url_expected = '/k-fet/accounts/'
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountValidFreeTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.is_validandfree.ajax'
url_expected = '/k-fet/accounts/is_validandfree'
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_ok_isvalid_isfree(self):
"""Upper case trigramme not taken is valid and free."""
r = self.client.get(self.url, {'trigramme': 'AAA'})
self.assertDictEqual(json.loads(r.content.decode('utf-8')), {
'is_valid': True,
'is_free': True,
})
def test_ok_isvalid_notfree(self):
"""Already taken trigramme is not free, but valid."""
r = self.client.get(self.url, {'trigramme': '000'})
self.assertDictEqual(json.loads(r.content.decode('utf-8')), {
'is_valid': True,
'is_free': False,
})
def test_ok_notvalid_isfree(self):
"""Lower case if forbidden but free."""
r = self.client.get(self.url, {'trigramme': 'aaa'})
self.assertDictEqual(json.loads(r.content.decode('utf-8')), {
'is_valid': False,
'is_free': True,
})
class AccountCreateViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.create'
url_expected = '/k-fet/accounts/new'
auth_user = 'team'
auth_forbidden = [None, 'user']
@property
def users_extra(self):
return {
'team__add_account': create_team(
'team__add_account', '101',
perms=['kfet.add_account'],
),
}
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
post_data = {
'trigramme': 'AAA',
'username': 'plopplopplop',
'first_name': 'first',
'last_name': 'last',
'email': 'email@domain.net',
}
client = Client()
client.login(
username='team__add_account',
password='team__add_account',
)
r = client.post(self.url, post_data)
self.assertRedirects(r, self.url)
a = Account.objects.get(trigramme='AAA')
self.assertEqual(a.username, 'plopplopplop')
def test_post_forbidden(self):
post_data = {
'trigramme': 'AAA',
'username': 'plopplopplop',
'first_name': 'first',
'last_name': 'last',
'email': 'email@domain.net',
}
# A team member (without kfet.add_account) is authenticated with
# self.client.
r = self.client.post(self.url, post_data)
self.assertEqual(r.status_code, 200)
with self.assertRaises(Account.DoesNotExist):
Account.objects.get(trigramme='AAA')
class AccountCreateAjaxViewTests(ViewTestCaseMixin, TestCase):
urls_conf = [
{
'name': 'kfet.account.create.fromuser',
'kwargs': {'username': 'user'},
'expected': '/k-fet/accounts/new/user/user',
},
{
'name': 'kfet.account.create.fromclipper',
'kwargs': {
'login_clipper': 'myclipper',
'fullname': 'first last1 last2',
},
'expected': (
'/k-fet/accounts/new/clipper/myclipper/first%20last1%20last2'
),
},
{
'name': 'kfet.account.create.empty',
'expected': '/k-fet/accounts/new/empty',
},
]
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_fromuser(self):
r = self.client.get(self.t_urls[0])
user = self.users['user']
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context['user_form'].instance, user)
self.assertEqual(r.context['cof_form'].instance, user.profile)
self.assertIn('account_form', r.context)
def test_fromclipper(self):
r = self.client.get(self.t_urls[1])
self.assertEqual(r.status_code, 200)
self.assertIn('user_form', r.context)
self.assertIn('cof_form', r.context)
self.assertIn('account_form', r.context)
def test_empty(self):
r = self.client.get(self.t_urls[0])
self.assertEqual(r.status_code, 200)
self.assertIn('user_form', r.context)
self.assertIn('cof_form', r.context)
self.assertIn('account_form', r.context)
class AccountCreateAutocompleteViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.create.autocomplete'
url_expected = '/k-fet/autocomplete/account_new'
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_ok(self):
r = self.client.get(self.url, {'q': 'first'})
self.assertEqual(r.status_code, 200)
self.assertListEqual(list(r.context['users_notcof']), [])
self.assertListEqual(list(r.context['users_cof']), [])
self.assertListEqual(
list(r.context['kfet']),
[(self.accounts['user'], self.users['user'])],
)
class AccountSearchViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.search.autocomplete'
url_expected = '/k-fet/autocomplete/account_search'
auth_user = 'team'
auth_forbidden = [None, 'user']
def test_ok(self):
r = self.client.get(self.url, {'q': 'first'})
self.assertEqual(r.status_code, 200)
self.assertListEqual(
list(r.context['accounts']),
[('000', 'first last')],
)
class AccountReadViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.read'
url_kwargs = {'trigramme': '001'}
url_expected = '/k-fet/accounts/001'
auth_user = 'team'
auth_forbidden = [None, 'user']
@property
def users_extra(self):
return {
'user1': create_user('user1', '001'),
}
def setUp(self):
# A user and its account
self.user = User.objects.create_user(username="foobar", password="foo")
acc = Account.objects.create(
trigramme="FOO", cofprofile=self.user.profile
)
super().setUp()
user1_acc = self.accounts['user1']
team_acc = self.accounts['team']
# Dummy operations and operation groups
checkout = Checkout.objects.create(
created_by=acc, name="checkout",
created_by=team_acc, name="checkout",
valid_from=timezone.now(),
valid_to=timezone.now() + timezone.timedelta(days=365)
)
@ -30,7 +247,7 @@ class AccountTests(TestCase):
]
OperationGroup.objects.bulk_create([
OperationGroup(
on_acc=acc, checkout=checkout, at=at, is_cof=False,
on_acc=user1_acc, checkout=checkout, at=at, is_cof=False,
amount=amount
)
for (at, amount) in opeg_data
@ -47,13 +264,112 @@ class AccountTests(TestCase):
amount=Decimal('3')
)
@patch('gestioncof.signals.messages')
def test_account_read(self, mock_messages):
"""We can query the "Account - Read" page."""
def test_ok(self):
"""We can query the "Account - Read" page."""
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_ok_self(self):
client = Client()
self.assertTrue(client.login(
username="foobar",
password="foo"
))
resp = client.get("/k-fet/accounts/FOO")
self.assertEqual(200, resp.status_code)
client.login(username='user1', password='user1')
r = client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountUpdateViewTests(ViewTestCaseMixin, TestCase):
url_name = 'kfet.account.update'
url_kwargs = {'trigramme': '001'}
url_expected = '/k-fet/accounts/001/edit'
auth_user = 'team'
auth_forbidden = [None, 'user']
@property
def users_extra(self):
return {
'user1': create_user('user1', '001'),
}
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_ok_self(self):
client = Client()
client.login(username='user1', password='user1')
r = client.get(self.url)
self.assertEqual(r.status_code, 200)
class BaseAccountGroupViewTests(ViewTestCaseMixin):
auth_user = 'team__manage_perms'
auth_forbidden = [None, 'user', 'team']
@property
def users_extra(self):
return {
'team__manage_perms': create_team(
'team__manage_perms', '101',
perms=['kfet.manage_perms'],
),
}
class AccountGroupListViewTests(BaseAccountGroupViewTests, TestCase):
url_name = 'kfet.account.group'
url_expected = '/k-fet/accounts/groups'
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
self.assertQuerysetEqual(
r.context['groups'],
Group.objects.filter(name__icontains='K-Fêt'),
ordered=False,
)
class AccountGroupCreateViewTests(BaseAccountGroupViewTests, TestCase):
url_name = 'kfet.account.group.create'
url_expected = '/k-fet/accounts/groups/new'
def test_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
class AccountGroupUpdateViewTests(BaseAccountGroupViewTests, TestCase):
url_name = 'kfet.account.group.update'
url_kwargs = {'pk': 42}
url_expected = '/k-fet/accounts/groups/42/edit'
def setUp(self):
super().setUp()
self.group1 = Group.objects.create(pk=42, name='K-Fêt - Group')
self.group1.permissions = [
Permission.objects.get(
content_type__app_label='kfet',
codename='is_team',
)
]
def test_get_ok(self):
r = self.client.get(self.url)
self.assertEqual(r.status_code, 200)
def test_post_ok(self):
post_data = {
'name': 'Group42',
'permissions': (
self.group1.permissions
.values_list('pk', flat=True)
),
}
r = self.client.post(self.url, post_data)
self.assertRedirects(r, reverse('kfet.account.group'))
self.group1.refresh_from_db()
self.assertEqual(self.group1.name, 'K-Fêt Group42')