def seed(self, i, entities=None):
user_properties = {
'key_name': 'user_%04d' % i,
'link_id': 'user_%04d' % i,
'account': users.User(email='*****@*****.**' % i),
'name': 'User %04d' % i,
}
entity = User(**user_properties)
if entities is None:
entity.put()
else:
entities.append(entity)
def seed(self, i, entities=None):
user_properties = {
'key_name': 'user_%04d' % i,
'link_id': 'user_%04d' % i,
'account': users.User(email='*****@*****.**' % i),
'name': 'User %04d' % i,
}
entity = User(**user_properties)
if entities is None:
entity.put()
user_logic._onCreate(entity)
else:
entities.append(entity)
def ensureUser():
"""Returns the current user account and associated user object.
"""
account = accounts.getCurrentAccount()
if not account:
account = users.User(email='*****@*****.**')
user_properties = {
'key_name': 'test',
'link_id': 'test',
'account': account,
'name': 'Test',
}
current_user = User(**user_properties)
current_user.put()
return account, current_user
def ensureUser():
"""Returns the current user account and associated user object.
"""
account = accounts.getCurrentAccount()
if not account:
account = users.User(email='*****@*****.**')
user_properties = {
'key_name': 'test',
'link_id': 'test',
'account': account,
'name': 'Test',
}
current_user = User(**user_properties)
current_user.put()
return account, current_user
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
user_properties = {
'account': users.get_current_user(),
'link_id': 'current_user',
'key_name': 'current_user',
'name': 'Current User',
}
self.user = User(**user_properties)
self.user.put()
# Create another user
another_user_properties = {
'account': users.User(email="*****@*****.**"),
'link_id': 'another_user',
'key_name': 'another_user',
'name': 'Another User',
}
self.another_user = User(**another_user_properties)
self.another_user.put()
# Create a dummy form object
self.form = Form()
def testCleanEmptyField(self):
"""Tests that empty field can be cleaned.
"""
field_name = '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), None)
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 = '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 = '*****@*****.**'
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 = '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
# link_id 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 link_id 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 testCleanScopePath(self):
"""Tests that scope_path field can be cleaned.
"""
field_name = 'scope_path'
clean_field = cleaning.clean_scope_path(field_name)
# Test that the value will be returned if the value of field
# has a valid scope_path format
field_value = 'valid_scope_path'
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 if the value of field
# has not a valid scope_path 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 = '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.link_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.link_id, self.user.link_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 = 'user'
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.link_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.link_id, self.user.link_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.link_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 = 'user'
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 link_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 link_id
field_value = self.user.link_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 = '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 link_id
field_value = self.user.link_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 link_id other than the current user
field_value = self.another_user.link_id
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form).link_id, self.another_user.link_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 testCleanUserAccount(self):
"""Test that user account can be cleaned.
"""
field_name = 'user_account'
clean_field = cleaning.clean_user_account(field_name)
# Test that a new account will be returned if the value of field is
# a valid new email address
field_value = '*****@*****.**'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
# Test that the existing account will be returned if the value of field is
# an existent user's email address
field_value = self.user.account.email()
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
self.assertEqual(cleaned_data_after, self.user.account)
# Test that a new account will be returned even if the value of field is
# an invalid email address
field_value = 'invalid_*mail'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form).email(), field_value)
def testCleanUserAccountNotInUse(self):
"""Tests that user account can be cleaned for non-existent user accounts.
"""
field_name = 'user_account_not_in_use'
clean_field = cleaning.clean_user_account_not_in_use(field_name)
# Test that a new account will be created and returned
# if the value of field is a valid new email address
field_value = '*****@*****.**'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
# Test that forms.ValidationError will be raised if the value of field is
# an existent user's email address
field_value = self.user.account.email()
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that a new account will be created and returned
# even if the value of field is an invalid email address
field_value = 'invalid_*mail'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
def testCleanValidShippingChars(self):
"""Tests that the shipping fields can be cleaned.
"""
field_name = 'ascii'
clean_field = cleaning.clean_valid_shipping_chars(field_name)
# Test that the value will be returned if the value of field is valid
field_value = 'ab12'
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 not valid ascii
field_value = u'\ua000'
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 = '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 = 'phone'
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 testCleanFeedUrl(self):
"""Tests that feed url can be cleaned.
Note: unlike other cleaning functions, it has not used a decorator.
So, the field name 'feed_url' is hardwired in the code.
"""
field_name = 'feed_url'
clean_field = cleaning.clean_feed_url(field_name)
# Test that the value of the feed url field will be returned if
# the value of the feed url field is an existent feed url
field_value = 'http://rss.cnn.com/rss/edition.rss'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), field_value)
# Test that None will be returned if the value of the feed url field is
# an empty string
field_value = ''
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), None)
# Test that forms.ValidationError error will be raised if the value of
# the feed url field is not an existent feed url
field_value = 'http://example.com/invalidfeed/'
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 = '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[6:-7]
self.assertEqual(clean_field(self.form), expected)
# Test that unicode is also supported
expected = html = u'\ua000'
self.form.cleaned_data = {field_name: html}
self.assertEqual(clean_field(self.form), expected)
# Test that input with scripts will raise forms.ValidationError
html = '<script></script>'
self.form.cleaned_data = {field_name: html}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that input can contain scripts when the current user is a developer
self.user.is_developer = True
self.user.put()
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 = '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), None)
# 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 = '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)
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
user_properties = {
'account': users.get_current_user(),
'link_id': 'current_user',
'key_name': 'current_user',
'name': 'Current User',
}
self.user = User(**user_properties)
self.user.put()
# Create another user
another_user_properties = {
'account': users.User(email="*****@*****.**"),
'link_id': 'another_user',
'key_name': 'another_user',
'name': 'Another User',
}
self.another_user = User(**another_user_properties)
self.another_user.put()
# Create a dummy form object
self.form = Form()
def testCleanEmptyField(self):
"""Tests that empty field can be cleaned.
"""
field_name = '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), None)
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 = '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 = '*****@*****.**'
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 = '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
# link_id 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 link_id 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 testCleanScopePath(self):
"""Tests that scope_path field can be cleaned.
"""
field_name = 'scope_path'
clean_field = cleaning.clean_scope_path(field_name)
# Test that the value will be returned if the value of field
# has a valid scope_path format
field_value = 'valid_scope_path'
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 if the value of field
# has not a valid scope_path 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 = '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.link_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.link_id, self.user.link_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 = 'user'
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.link_id
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.link_id, self.user.link_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.link_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 = 'user'
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 link_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 link_id
field_value = self.user.link_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 = '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 link_id
field_value = self.user.link_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 link_id other than the current user
field_value = self.another_user.link_id
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(
clean_field(self.form).link_id, self.another_user.link_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 testCleanUserAccount(self):
"""Test that user account can be cleaned.
"""
field_name = 'user_account'
clean_field = cleaning.clean_user_account(field_name)
# Test that a new account will be returned if the value of field is
# a valid new email address
field_value = '*****@*****.**'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
# Test that the existing account will be returned if the value of field is
# an existent user's email address
field_value = self.user.account.email()
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
self.assertEqual(cleaned_data_after, self.user.account)
# Test that a new account will be returned even if the value of field is
# an invalid email address
field_value = 'invalid_*mail'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form).email(), field_value)
def testCleanUserAccountNotInUse(self):
"""Tests that user account can be cleaned for non-existent user accounts.
"""
field_name = 'user_account_not_in_use'
clean_field = cleaning.clean_user_account_not_in_use(field_name)
# Test that a new account will be created and returned
# if the value of field is a valid new email address
field_value = '*****@*****.**'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
# Test that forms.ValidationError will be raised if the value of field is
# an existent user's email address
field_value = self.user.account.email()
self.form.cleaned_data = {field_name: field_value}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that a new account will be created and returned
# even if the value of field is an invalid email address
field_value = 'invalid_*mail'
self.form.cleaned_data = {field_name: field_value}
cleaned_data_after = clean_field(self.form)
self.assertEqual(cleaned_data_after.email(), field_value)
def testCleanValidShippingChars(self):
"""Tests that the shipping fields can be cleaned.
"""
field_name = 'ascii'
clean_field = cleaning.clean_valid_shipping_chars(field_name)
# Test that the value will be returned if the value of field is valid
field_value = 'ab12'
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 not valid ascii
field_value = u'\ua000'
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 = '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 = 'phone'
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 testCleanFeedUrl(self):
"""Tests that feed url can be cleaned.
Note: unlike other cleaning functions, it has not used a decorator.
So, the field name 'feed_url' is hardwired in the code.
"""
field_name = 'feed_url'
clean_field = cleaning.clean_feed_url(field_name)
# Test that the value of the feed url field will be returned if
# the value of the feed url field is an existent feed url
field_value = 'http://rss.cnn.com/rss/edition.rss'
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), field_value)
# Test that None will be returned if the value of the feed url field is
# an empty string
field_value = ''
self.form.cleaned_data = {field_name: field_value}
self.assertEqual(clean_field(self.form), None)
# Test that forms.ValidationError error will be raised if the value of
# the feed url field is not an existent feed url
field_value = 'http://example.com/invalidfeed/'
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 = '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[6:-7]
self.assertEqual(clean_field(self.form), expected)
# Test that unicode is also supported
expected = html = u'\ua000'
self.form.cleaned_data = {field_name: html}
self.assertEqual(clean_field(self.form), expected)
# Test that input with scripts will raise forms.ValidationError
html = '<script></script>'
self.form.cleaned_data = {field_name: html}
self.assertRaises(forms.ValidationError, clean_field, self.form)
# Test that input can contain scripts when the current user is a developer
self.user.is_developer = True
self.user.put()
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 = '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), None)
# 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 = '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 seed(request, *args, **kwargs):
"""Seeds the datastore with some default values.
"""
site_properties = {
'key_name': 'site',
'link_id': 'site',
}
site = Site(**site_properties)
site.put()
account = accounts.getCurrentAccount()
if not account:
account = users.User(email='*****@*****.**')
user_properties = {
'key_name': 'test',
'link_id': 'test',
'account': account,
'name': 'Test',
}
current_user = User(**user_properties)
current_user.put()
group_properties = {
'key_name': 'google',
'link_id': 'google',
'name': 'Google Inc.',
'short_name': 'Google',
'founder': current_user,
'home_page': 'http://www.google.com',
'email': '*****@*****.**',
'description': 'This is the profile for Google.',
'contact_street': 'Some Street',
'contact_city': 'Some City',
'contact_country': 'United States',
'contact_postalcode': '12345',
'phone': '1-555-BANANA',
'status': 'active',
}
google = Sponsor(**group_properties)
google.put()
role_properties = {
'key_name': 'google/test',
'link_id': 'test',
'public_name': 'test',
'scope': google,
'scope_path': 'google',
'user': current_user,
'given_name': 'Test',
'surname': 'Example',
'name_on_documents': 'Test Example',
'email': '*****@*****.**',
'res_street': 'Some Street',
'res_city': 'Some City',
'res_state': 'Some State',
'res_country': 'United States',
'res_postalcode': '12345',
'phone': '1-555-BANANA',
'birth_date': db.DateProperty.now(),
'agreed_to_tos': True,
'is_org_admin': True,
'is_mentor': True,
}
current_user.host_for = [google.key()]
current_user.put()
google_host = Host(**role_properties)
google_host.put()
from datetime import datetime
from datetime import timedelta
now = datetime.now()
before = now - timedelta(365)
after = now + timedelta(365)
timeline_properties = {
'key_name': 'google/gsoc2009',
'link_id': 'gsoc2009',
'scope_path': 'google',
'scope': google,
'program_start': before,
'program_end': after,
'accepted_organization_announced_deadline': before,
'student_signup_start': before,
'student_signup_end': after,
}
gsoc2009_timeline = GSoCTimeline(**timeline_properties)
gsoc2009_timeline.put()
program_properties = {
'key_name': 'google/gsoc2009',
'link_id': 'gsoc2009',
'scope_path': 'google',
'scope': google,
'name': 'Google Summer of Code 2009',
'short_name': 'GSoC 2009',
'group_label': 'GSOC',
'description': 'This is the program for GSoC 2009.',
'apps_tasks_limit': 42,
'slots': 42,
'timeline': gsoc2009_timeline,
'status': 'visible',
}
gsoc2009 = GSoCProgram(**program_properties)
gsoc2009.put()
timeline_properties.update({
'key_name': 'google/gsoc2010',
'link_id': 'gsoc2010',
})
gsoc2010_timeline = GSoCTimeline(**timeline_properties)
gsoc2010_timeline.put()
program_properties.update({
'key_name': 'google/gsoc2010',
'link_id': 'gsoc2010',
'name': 'Google Summer of Code 2010',
'description': 'This is the program for GSoC 2010.',
'short_name': 'GSoC 2010',
'timeline': gsoc2010_timeline,
})
gsoc2010 = GSoCProgram(**program_properties)
gsoc2010.put()
timeline_properties = {
'key_name': 'google/gci2009',
'link_id': 'gci2009',
'scope_path': 'google',
'scope': google,
'program_start': before,
'program_end': after,
'accepted_organization_announced_deadline': before,
'student_signup_start': before,
'student_signup_end': after,
'tasks_publicly_visible': before,
'task_claim_deadline': after,
'stop_all_work_deadline': after,
}
gci2009_timeline = GCITimeline(**timeline_properties)
gci2009_timeline.put()
program_properties.update({
'key_name': 'google/gci2009',
'link_id': 'gci2009',
'name': 'Google Code In Contest 2009',
'short_name': 'GCI 2009',
'group_label': 'GCI',
'description': 'This is the program for GCI 2009.',
'timeline': gci2009_timeline,
})
gci2009 = GCIProgram(**program_properties)
gci2009.put()
site.active_program = gci2009
site.put()
group_properties.update({
'key_name': 'google/gci2009/melange',
'link_id': 'melange',
'name': 'Melange Development Team',
'short_name': 'Melange',
'scope_path': 'google/gci2009',
'scope': gci2009,
'home_page': 'http://code.google.com/p/soc',
'description': 'Melange, share the love!',
'license_name': 'Apache License',
'ideas': 'http://code.google.com/p/soc/issues',
})
melange = GCIOrganization(**group_properties)
melange.put()
group_properties.update({
'scope_path': 'google/gsoc2009',
'scope': gsoc2009,
})
role_properties.update({
'key_name': 'google/gsoc2009/test',
'link_id': 'test',
'scope_path': 'google/gsoc2009',
'scope': gsoc2009,
'program': gsoc2009,
'parent': current_user,
})
profile = GSoCProfile(**role_properties)
role_properties.pop('parent')
orgs = []
for i in range(15):
group_properties.update({
'key_name': 'google/gsoc2009/org_%d' % i,
'link_id': 'org_%d' % i,
'name': 'Organization %d' % i,
'short_name': 'Org %d' % i,
'description': 'Organization %d!' % i,
})
entity = GSoCOrganization(**group_properties)
orgs.append(entity)
entity.put()
# Admin (and thus mentor) for the first org
if i == 0:
profile.org_admin_for.append(entity.key())
profile.mentor_for.append(entity.key())
profile.is_mentor = True
profile.is_org_admin = True
profile.put()
# Mentor for the second org
if i == 1:
profile.mentor_for.append(entity.key())
profile.is_mentor = True
profile.put()
role_properties.update({
'key_name': 'google/gci2009/test',
'link_id': 'test',
'scope_path': 'google/gci2009',
'scope': gci2009,
'program': gci2009,
'org_admin_for': [melange.key()],
'mentor_for': [melange.key()],
'parent': current_user,
})
melange_admin = GCIProfile(**role_properties)
# TODO: add GCI orgs
melange_admin.put()
task_properties = {
'status': 'Open',
'modified_by': melange_admin.key(),
'subscribers': [melange_admin.key()],
'title': 'Awesomeness',
'created_by': melange_admin.key(),
'created_on': now,
'program': gci2009,
'time_to_complete': 1337,
'modified_on': now,
'org': melange.key(),
'description': '<p>AWESOME</p>',
'difficulty_level': DifficultyLevel.MEDIUM,
'types': ['Code']
}
gci_task = GCITask(**task_properties)
gci_task.put()
user_properties = {
'key_name': 'student',
'link_id': 'student',
'account': users.User(email='*****@*****.**'),
'name': 'Student',
}
student_user = User(**user_properties)
student_user.put()
student_id = 'student'
student_properties = {
'key_name': gsoc2009.key().name() + "/" + student_id,
'link_id': student_id,
'scope_path': gsoc2009.key().name(),
'parent': student_user,
'scope': gsoc2009,
'program': gsoc2009,
'user': student_user,
'is_student': True,
'public_name': 'Student',
'given_name': 'Student',
'surname': 'Student',
'birth_date': db.DateProperty.now(),
'email': '*****@*****.**',
'im_handle': 'student_im_handle',
'major': 'test major',
'name_on_documents': 'Student',
'res_country': 'United States',
'res_city': 'city',
'res_street': 'test street',
'res_postalcode': '12345',
'publish_location': True,
'blog': 'http://www.blog.com/',
'home_page': 'http://www.homepage.com/',
'photo_url': 'http://www.photosite.com/thumbnail.png',
'ship_state': None,
'tshirt_size': 'XS',
'tshirt_style': 'male',
'degree': 'Undergraduate',
'phone': '1650253000',
'can_we_contact_you': True,
'program_knowledge': 'I heard about this program through a friend.'
}
melange_student = GSoCProfile(**student_properties)
student_info_properties = {
'key_name': melange_student.key().name(),
'parent': melange_student,
'expected_graduation': 2009,
'program': gsoc2009,
'school_country': 'United States',
'school_name': 'Test School',
'school_home_page': 'http://www.example.com',
'program': gsoc2009,
}
student_info = GSoCStudentInfo(**student_info_properties)
student_info.put()
melange_student.student_info = student_info
melange_student.put()
user_properties = {
'key_name': 'student2',
'link_id': 'student2',
'account': users.User(email='*****@*****.**'),
'name': 'Student 2',
}
student_user2 = User(**user_properties)
student_user2.put()
student_id = 'student2'
student_properties.update({
'key_name': gsoc2009.key().name() + "/" + student_id,
'link_id': student_id,
'user': student_user2,
'parent': student_user2,
})
melange_student2 = GSoCProfile(**student_properties)
melange_student2.put()
project_id = 'test_project'
project_properties = {
'key_name': gsoc2009.key().name() + "/org_1/" + project_id,
'link_id': project_id,
'scope_path': gsoc2009.key().name() + "/org_1",
'scope': orgs[1].key(),
'title': 'test project',
'abstract': 'test abstract',
'status': 'accepted',
'student': melange_student,
'mentor': profile,
'program': gsoc2009
}
melange_project = StudentProject(**project_properties)
melange_project.put()
student_info_properties.update({'number_of_projects': 1,
'project_for_orgs': [orgs[1].key()]})
student_info = GSoCStudentInfo(**student_info_properties)
student_info.put()
melange_student.student_info = student_info
melange_student.put()
project_id = 'test_project2'
project_properties.update({
'key_name': gsoc2009.key().name() + "/org_1/" + project_id,
'link_id': project_id,
'student': melange_student2,
'title': 'test project2'
})
student_info_properties.update({
'key_name': gsoc2009.key().name() + "/" + student_id,
'link_id': student_id,
'parent': melange_student2,
})
student_info2 = GSoCStudentInfo(**student_info_properties)
student_info2.put()
melange_student2.student_info = student_info2
melange_student2.put()
melange_project2 = StudentProject(**project_properties)
melange_project2.put()
student_id = 'student'
student_properties.update({
'key_name': gci2009.key().name() + '/' + student_id,
'parent': student_user,
'scope': gci2009,
'scope_path': gci2009.key().name(),
})
gci_student = GCIProfile(**student_properties)
gci_student.put()
student_info_properties.update({
'key_name': gci_student.key().name(),
'parent': gci_student,
'program': gci2009,
})
student_info = GCIStudentInfo(**student_info_properties)
student_info.put()
gci_student.student_info = student_info
gci_student.put()
score_properties = {
'parent': gci_student,
'program': gci2009,
'points': 5,
'tasks': [gci_task.key()]
}
score = GCIScore(**score_properties)
score.put()
document_properties = {
'key_name': 'site/site/home',
'link_id': 'home',
'scope_path': 'site',
'scope': site,
'prefix': 'site',
'author': current_user,
'title': 'Home Page',
'short_name': 'Home',
'content': 'This is the Home Page',
'modified_by': current_user,
}
home_document = Document(**document_properties)
home_document.put()
document_properties = {
'key_name': 'user/test/notes',
'link_id': 'notes',
'scope_path': 'test',
'scope': current_user,
'prefix': 'user',
'author': current_user,
'title': 'My Notes',
'short_name': 'Notes',
'content': 'These are my notes',
'modified_by': current_user,
}
notes_document = Document(**document_properties)
notes_document.put()
site.home = home_document
site.put()
# pylint: disable=E1101
memcache.flush_all()
return http.HttpResponse('Done')
