blob: e2271aa72a1268d1b3f4602ab61d59285780ac2d [file] [log] [blame]
# Copyright 2011 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from django import forms
from seeder import user as user_seeder
from melange.utils import countries
from soc.logic import cleaning
from tests import profile_utils
from tests.test_utils import GSoCDjangoTestCase
class Form(object):
"""A dummy form class for CleaningTest.
"""
def __init__(self):
"""Initialization.
"""
self.cleaned_data = {}
self._errors = {}
class CleaningTest(GSoCDjangoTestCase):
"""Tests related to cleaning logic.
"""
def setUp(self):
"""Set up required for the cleaning logic tests.
"""
self.init()
# Ensure that current user is created
self.user = user_seeder.seedUser()
profile_utils.loginNDB(self.user)
# Create another user
self.another_user = user_seeder.seedUser()
# Create a dummy form object
self.form = Form()
def testCleanEmptyField(self):
"""Tests that empty field can be cleaned.
"""
field_name = 'test_empty_field'
clean_field = cleaning.clean_empty_field(field_name)
# Test that the same value will be returned, the cleaned_data of form
# does not change and there is no error message if the value of field
# is not empty
field_value = 'v1_@?'
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertEqual(clean_field(self.form), field_value)
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
# Test that None will be returned, the cleaned_data of form does not change
# and there is no error message if the value of field is empty
field_value = ''
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertEqual(clean_field(self.form), u'')
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
def testCleanEmail(self):
"""Tests that an email is cleaned.
"""
field_name = 'test_email'
clean_field = cleaning.clean_email(field_name)
#Test that the same value is returned, the cleaned_data of the from does
#not change and there is no error message if the value of the field has a
#valid email
field_value = 'test@example.com'
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertEqual(clean_field(self.form), field_value)
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
#Test that forms.ValidationError is raised if email is not valid.
field_value = '#$test&*('
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertRaises(forms.ValidationError, clean_field, self.form)
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
def testCleanLinkId(self):
"""Tests that link_id field can be cleaned."""
field_name = 'test_link_id'
clean_field = cleaning.clean_link_id(field_name)
# Test that the value will be returned, the cleaned_data of form does not
# change and there is no error message if the value of field has a valid
# format
field_value = 'valid_link_id'
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertEqual(clean_field(self.form), field_value)
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
# Test that forms.ValidationError will be raised, the cleaned_data of form
# does not change and there is no error message if the value of field has
# not a valid format
field_value = 'v1_@?'
cleaned_data_before = {field_name: field_value}
self.form.cleaned_data = cleaned_data_before.copy()
self.assertRaises(forms.ValidationError, clean_field, self.form)
self.assertEqual(self.form.cleaned_data, cleaned_data_before)
self.assertEqual(self.form._errors, {})
def testCleanExistingUser(self):
"""Tests that the user field can be cleaned for existing users.
"""
field_name = 'test_existing_user'
clean_field = cleaning.clean_existing_user(field_name)
# Test that the user will be returned if the value of field
# is an existent user's link_id
field_value = self.user.user_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.user_id, self.user.user_id)
# Test that forms.ValidationError will be raised if the value of field
# is not an existent user's link_id
field_value = 'non_existent_user'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanUserIsCurrent(self):
"""Tests that the user field can be cleaned for current users.
"""
field_name = 'test_user_is_current'
clean_field = cleaning.clean_user_is_current(field_name)
# Test that the user will be returned if the value of field is
# an existent user's link_id
field_value = self.user.user_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.user_id, self.user.user_id)
# Test that forms.ValidationError will be raised if the value of field
# is a user's link_id other than the current user's
field_value = self.another_user.user_id
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that forms.ValidationError will be raised if the value of field
# is not an existent user's link_id
field_value = 'non_existent_user'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanUserNotExist(self):
"""Tests that the user field can be cleaned for non-existent users.
"""
field_name = 'test_user_not_exist'
clean_field = cleaning.clean_user_not_exist(field_name)
# Test that the value will be returned if the value of field
# is not an existent user's user_id
field_value = 'non_existent_user'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), field_value)
# Test that forms.ValidationError will be raised if the value of field
# is an existent user's user_id
field_value = self.user.user_id
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanUsersNotSame(self):
"""Tests that the user field can be cleaned for non current users.
"""
field_name = 'test_not_current_user'
clean_field = cleaning.clean_users_not_same(field_name)
# Test that forms.ValidationError will be raised if the value of field
# is the current user's user_id
field_value = self.user.user_id
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that the user will be returned if the value of field is
# a user's user_id other than the current user
field_value = self.another_user.user_id
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form).user_id, self.another_user.user_id)
# Test that forms.ValidationError will be raised if the value of field
# is not an existent user's user_id
field_value = 'non_existent_user'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanContentLength(self):
"""Tests that content length can be cleaned.
"""
field_name = 'test_content_length'
clean_field = cleaning.clean_content_length(field_name, 3, 5)
# Test that the value will be returned if the length of the value of field
# is within min_length and max_length
field_value = 'a1&'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), field_value)
# Test that forms.ValidationError will be raised if the length of the value
# of field is less than min_length
field_value = 'ab'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that forms.ValidationError will be raised if the length of the value
# of field is more than max_length
field_value = 'ab12&*'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanPhoneNumber(self):
"""Tests that phone number can be cleaned.
"""
field_name = 'test_phone_number'
clean_field = cleaning.clean_phone_number(field_name)
# Test that the phone number will be returned if it contains digits only
field_value = '0010208636479'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), field_value)
# Test that forms.ValidationError will be raised if
# the phone number contains non digits (except '+')
field_value = '001-020-8636479'
self.form.cleaned_data[field_name] = field_value
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that the '+' will be replaced with 00 and then the modified number
# will be returned if the phone number starts with a '+'
field_value = '+10208636479'
self.form.cleaned_data[field_name] = field_value
expected = '00' + field_value[1:]
self.assertEqual(clean_field(self.form), expected)
# Test that forms.ValidationError will be raised if
# a '+' is in the middle of the phone number
field_value = '1+0208636479'
self.form.cleaned_data[field_name] = field_value
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that forms.ValidationError will be raised if
# a '+' is at the end of the phone number
field_value = '10208636479+'
self.form.cleaned_data[field_name] = field_value
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanHtmlContent(self):
"""Tests that html content can be cleaned.
"""
field_name = 'test_html'
clean_field = cleaning.clean_html_content(field_name)
# Test that normal html can be cleaned
expected = html = '<div>f9-+@4</div>'
self.form.cleaned_data = {field_name: html}
self.assertEqual(clean_field(self.form), expected)
# Test that normal html can be cleaned
html = '<html>f9-+@4</html>'
self.form.cleaned_data = {field_name: html}
expected = html.replace('<', '&lt;').replace('>', '&gt;')
actual = clean_field(self.form)
self.assertEqual(actual, expected)
expected = html = u'\ua000'
self.form.cleaned_data = {field_name: html}
self.assertEqual(clean_field(self.form), expected)
# Test that input with scripts will be encoded as well
html = '<script></script>'
self.form.cleaned_data = {field_name: html}
actual = clean_field(self.form)
expected = html.replace('<', '&lt;').replace('>', '&gt;')
self.assertEqual(actual, expected)
# Test that input can contain scripts when the current user is a developer
profile_utils.loginNDB(self.user, is_admin=True)
expected = html = '<script></script>'
self.form.cleaned_data = {field_name: html}
self.assertEqual(clean_field(self.form), expected)
def testCleanUrl(self):
"""Tests that url can be cleaned.
"""
field_name = 'test_url'
clean_field = cleaning.clean_url(field_name)
# Test that the value of the url field will be returned
# if it is a valid url
field_value = 'http://exampleabc.com/'
self.form.cleaned_data = {field_name: field_value}
self.form.fields = {field_name: forms.URLField()}
self.assertEqual(clean_field(self.form), field_value)
# Test that None will be returned if the value of the url field
# is an empty string
field_value = ''
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), u'')
# Test that forms.ValidationError error will be raised
# if the value of the url field is not a valid url
field_value = 'exampleabc'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testStr2Set(self):
"""Tests if symbol separated strings are cleaned.
"""
string_field = 'test_string_field'
clean_field = cleaning.str2set(string_field, separator=',')
string_field_value = "a,b,c"
cleaned_data_before = {string_field: string_field_value}
self.form.cleaned_data = cleaned_data_before
expected = string_field_value.split(',')
self.assertEqual(clean_field(self.form), expected)
string_field_value = "a"
cleaned_data_before = {string_field: string_field_value}
self.form.cleaned_data = cleaned_data_before
expected = string_field_value.split()
self.assertEqual(clean_field(self.form), expected)
string_field_value = "a b c"
clean_field = cleaning.str2set(string_field, separator=' ')
cleaned_data_before = {string_field: string_field_value}
self.form.cleaned_data = cleaned_data_before
expected = string_field_value.split()
self.assertEqual(clean_field(self.form), expected)
string_field_value = "a, b, c, a"
clean_field = cleaning.str2set(string_field, separator=',')
cleaned_data_before = {string_field: string_field_value}
self.form.cleaned_data = cleaned_data_before
temp = string_field_value.split(',')
expected = set([char.strip() for char in temp])
actual = set(clean_field(self.form))
self.assertEqual(expected, actual)
def testCleanIrc(self):
"""Tests cleaning.clean_irc."""
field_name = 'test_irc'
clean_field = cleaning.clean_irc(field_name)
# Test that the value of the irc field will be returned
# if it is a valid irc url
field_value = 'irc://exampleirc.com/'
self.form.cleaned_data = {field_name: field_value}
self.form.fields = {field_name: forms.URLField()}
self.assertEqual(clean_field(self.form), field_value)
# Test that the value of the irc field will be returned
# if it is a valid irc url with channels
field_value = 'irc://exampleirc.com/#channel'
self.form.cleaned_data = {field_name: field_value}
self.form.fields = {field_name: forms.URLField()}
self.assertEqual(clean_field(self.form), field_value)
# Test that empty string will be returned if the value of the irc field
# is an empty string
field_value = ''
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), u'')
# Test that forms.ValidationError will be raised
# if the value of the irc field is not a valid irc url
field_value = 'http://exampleirc'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that forms.ValidationError will be raised
# if the value of the irc field is not a valid irc url
field_value = 'irc://kthxbai$/'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
def testCleanMailto(self):
"""Tests cleaning.clean_mailto."""
field_name = 'test_mailto'
clean_field = cleaning.clean_mailto(field_name)
# Test that the value of the mail url field will be returned
# if it is a valid mail url
field_value = 'mailto:someone@something.com'
self.form.cleaned_data = {field_name: field_value}
self.form.fields = {field_name: forms.URLField()}
self.assertEqual(clean_field(self.form), field_value)
# Test that empty string will be returned if the value of the mailto field
# is an empty string
field_value = ''
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), u'')
# Test that forms.ValidationError will be raised
# if the value of the mailto field is not a valid mailto or http url.
field_value = 'someone@something.com'
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that the value of the mailto field will be returned
# if it is a valid http url ( a mailing group, say)
field_value = 'http://example.com/hereisawebmailinggroup'
self.form.cleaned_data = {field_name: field_value}
self.form.fields = {field_name: forms.URLField()}
self.assertEqual(clean_field(self.form), field_value)
class CleanValidAddressCharactersTest(unittest.TestCase):
"""Unit tests for cleanValidAddressCharacters function."""
def testValidValues(self):
"""Tests that value is cleaned correctly for valid values."""
self.assertIsNone(cleaning.cleanValidAddressCharacters(None))
self.assertEqual('', cleaning.cleanValidAddressCharacters(''))
self.assertEqual('ab 12 a', cleaning.cleanValidAddressCharacters('ab 12 a'))
self.assertEqual('AB 12 a', cleaning.cleanValidAddressCharacters('AB 12 a'))
self.assertEqual('AB 1/2', cleaning.cleanValidAddressCharacters('AB 1/2'))
self.assertEqual('A-B', cleaning.cleanValidAddressCharacters('A-B'))
self.assertEqual('1,2,3', cleaning.cleanValidAddressCharacters('1,2,3'))
self.assertEqual('1.2.3', cleaning.cleanValidAddressCharacters('1.2.3'))
def testInvalidValues(self):
"""Tests that an error is raised for invalid values."""
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters(u'\ua000')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters(u'\u0105')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('#')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('(1)')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('&-2')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a\\b')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a!')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a%')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('[a]')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('{a}')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a:')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a;')
with self.assertRaises(forms.ValidationError):
cleaning.cleanValidAddressCharacters('a?')
class CleanValidCountry(unittest.TestCase):
"""Unit tests for clean_country function."""
def _assertCleansToSame(self, country):
"""Tests that the input and output of the cleaner are identical."""
self.assertEqual(country, cleaning.clean_country(country))
def testValidValues(self):
"""Tests that value is cleaned correctly for valid values."""
for country in countries.COUNTRIES_AND_TERRITORIES:
self._assertCleansToSame(country)
def testInvalidValues(self):
with self.assertRaises(forms.ValidationError):
cleaning.clean_country('some random words')
with self.assertRaises(forms.ValidationError):
cleaning.clean_country('') # empty string
with self.assertRaises(forms.ValidationError):
cleaning.clean_country(None) # None