Module to simplify testing forms in Django framework
Project description
# django-forms-test
Module to simplify testing forms in Django framework
## Installation
You can simply install it with use of `pip`:
`pip install git+https://github.com/Thyrst/django-forms-test.git`
Then you'll import it into your testing script like this:
`from django_forms_test import field, cleaned, FormTest`
## Usage
You will create a subclass of `FormTest` which is subclass of `django.test.TestCase`, so you can add tests as you are used to. To the attribute `form` you assign class of the form you are testing. `required_fields` should be a list of fields required by your form.
```python
class YourClass(FormTest):
form = YourForm
required_fields = ['email', 'message']
```
Instead of the name of a field you can use a tuple of name and field type. Available field types are `URL`, `TEXT`, `PASSWORD`, `USERNAME`, `EMAIL`. Field types serves to additional checking of permitted field value (e.g. a form shouldn't accept an invalid URL). The `TEXT` is the default type and has no additional verifications.
```python
class YourClass(FormTest):
form = YourForm
required_fields = [('email', field.EMAIL), 'message'] # same as ('message', field.TEXT)
```
For testing of form's cleaning methods you can use a decorator `cleaned` which accepts the input field values as arguments and passes them cleaned to your function.
```python
class YourClass(FormTest):
form = YourForm
@cleaned(nick=' Bob ')
def test_strip_nick(self, nick):
self.assertEqual(nick, 'Bob')
```
## Example
You code this:
```python
class SaveFormTest(FormTest):
form = SaveForm
required_fields = ['title', 'tags', ('url', field.URL)]
@cleaned(tags='one, two')
def test_cleaning_tags(self, tags):
self.assertIsInstance(tags, list)
self.assertEqual(len(tags), 2)
self.assertEqual(tags[1], 'two')
@cleaned(description='')
def test_cleaning_description(self, description):
self.assertIsNone(description)
```
Instead of this:
```python
class SaveFormTest(TestCase):
data = {
'title': 'some title',
'url': 'http://some.url',
'tags': 'some tags',
}
def test_valid_form(self):
form = SaveForm(self.data)
self.assertTrue(form.is_valid())
def test_invalid_url(self):
my_data = copy(self.data)
my_data['url'] = 'invalid url'
form = SaveForm(my_data)
self.assertFalse(form.is_valid())
def test_required_fields(self):
for field in ('title', 'url', 'tags'):
with self.subTest(field=field):
my_data = copy(self.data)
my_data[field] = ''
form = SaveForm(my_data)
self.assertFalse(form.is_valid())
def test_cleaning_tags(self):
form = SaveForm({'tags': 'one, two'})
form.is_valid()
tags = form.cleaned_data['tags']
self.assertIsInstance(tags, list)
self.assertEqual(len(tags), 2)
self.assertEqual(tags[1], 'two')
def test_cleaning_description(self):
form = SaveForm({'description': ''})
form.is_valid()
description = form.cleaned_data['description']
self.assertIsNone(description)
```
And you code this:
```python
class RegisterFormTest(FormTest):
form = RegisterForm
required_fields = [
('username', field.USERNAME),
('email', field.EMAIL),
('password', field.PASSWORD),
('confirm_password', field.PASSWORD),
]
```
Instead of this:
```python
class RegisterFormTest(TestCase):
data = {
'username': 'some_username',
'email': 'some@email.com',
'password': 'some password',
'confirm_password': 'some password',
}
def test_valid_form(self):
form = RegisterForm(self.data)
self.assertTrue(form.is_valid())
def test_invalid_username(self):
my_data = copy(self.data)
my_data['email'] = 'invalid email'
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_invalid_email(self):
my_data = copy(self.data)
my_data['email'] = 'invalid email'
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_required_fields(self):
for field in ('username', 'email', 'password', 'confirm_password'):
with self.subTest(field=field):
my_data = copy(self.data)
my_data[field] = ''
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_password_safe_input(self):
form = RegisterForm()
input_type = form['password'].field.widget.input_type
self.assertEqual(input_type, 'password')
input_type = form['confirm_password'].field.widget.input_type
self.assertEqual(input_type, 'password')
```
## Announcement
I've done this just for my personal use, so there are many things that are still missing and I probably won't implement them until I need them. However feel free to send a pull request if you miss something.
Module to simplify testing forms in Django framework
## Installation
You can simply install it with use of `pip`:
`pip install git+https://github.com/Thyrst/django-forms-test.git`
Then you'll import it into your testing script like this:
`from django_forms_test import field, cleaned, FormTest`
## Usage
You will create a subclass of `FormTest` which is subclass of `django.test.TestCase`, so you can add tests as you are used to. To the attribute `form` you assign class of the form you are testing. `required_fields` should be a list of fields required by your form.
```python
class YourClass(FormTest):
form = YourForm
required_fields = ['email', 'message']
```
Instead of the name of a field you can use a tuple of name and field type. Available field types are `URL`, `TEXT`, `PASSWORD`, `USERNAME`, `EMAIL`. Field types serves to additional checking of permitted field value (e.g. a form shouldn't accept an invalid URL). The `TEXT` is the default type and has no additional verifications.
```python
class YourClass(FormTest):
form = YourForm
required_fields = [('email', field.EMAIL), 'message'] # same as ('message', field.TEXT)
```
For testing of form's cleaning methods you can use a decorator `cleaned` which accepts the input field values as arguments and passes them cleaned to your function.
```python
class YourClass(FormTest):
form = YourForm
@cleaned(nick=' Bob ')
def test_strip_nick(self, nick):
self.assertEqual(nick, 'Bob')
```
## Example
You code this:
```python
class SaveFormTest(FormTest):
form = SaveForm
required_fields = ['title', 'tags', ('url', field.URL)]
@cleaned(tags='one, two')
def test_cleaning_tags(self, tags):
self.assertIsInstance(tags, list)
self.assertEqual(len(tags), 2)
self.assertEqual(tags[1], 'two')
@cleaned(description='')
def test_cleaning_description(self, description):
self.assertIsNone(description)
```
Instead of this:
```python
class SaveFormTest(TestCase):
data = {
'title': 'some title',
'url': 'http://some.url',
'tags': 'some tags',
}
def test_valid_form(self):
form = SaveForm(self.data)
self.assertTrue(form.is_valid())
def test_invalid_url(self):
my_data = copy(self.data)
my_data['url'] = 'invalid url'
form = SaveForm(my_data)
self.assertFalse(form.is_valid())
def test_required_fields(self):
for field in ('title', 'url', 'tags'):
with self.subTest(field=field):
my_data = copy(self.data)
my_data[field] = ''
form = SaveForm(my_data)
self.assertFalse(form.is_valid())
def test_cleaning_tags(self):
form = SaveForm({'tags': 'one, two'})
form.is_valid()
tags = form.cleaned_data['tags']
self.assertIsInstance(tags, list)
self.assertEqual(len(tags), 2)
self.assertEqual(tags[1], 'two')
def test_cleaning_description(self):
form = SaveForm({'description': ''})
form.is_valid()
description = form.cleaned_data['description']
self.assertIsNone(description)
```
And you code this:
```python
class RegisterFormTest(FormTest):
form = RegisterForm
required_fields = [
('username', field.USERNAME),
('email', field.EMAIL),
('password', field.PASSWORD),
('confirm_password', field.PASSWORD),
]
```
Instead of this:
```python
class RegisterFormTest(TestCase):
data = {
'username': 'some_username',
'email': 'some@email.com',
'password': 'some password',
'confirm_password': 'some password',
}
def test_valid_form(self):
form = RegisterForm(self.data)
self.assertTrue(form.is_valid())
def test_invalid_username(self):
my_data = copy(self.data)
my_data['email'] = 'invalid email'
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_invalid_email(self):
my_data = copy(self.data)
my_data['email'] = 'invalid email'
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_required_fields(self):
for field in ('username', 'email', 'password', 'confirm_password'):
with self.subTest(field=field):
my_data = copy(self.data)
my_data[field] = ''
form = RegisterForm(my_data)
self.assertFalse(form.is_valid())
def test_password_safe_input(self):
form = RegisterForm()
input_type = form['password'].field.widget.input_type
self.assertEqual(input_type, 'password')
input_type = form['confirm_password'].field.widget.input_type
self.assertEqual(input_type, 'password')
```
## Announcement
I've done this just for my personal use, so there are many things that are still missing and I probably won't implement them until I need them. However feel free to send a pull request if you miss something.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
django-forms-test-0.1.tar.gz
(3.3 kB
view hashes)