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 clean_email(self): email_cleaner = cleaning.clean_email('email') try: email_address = email_cleaner(self) except djangoforms.ValidationError as e: if e.code != 'invalid': raise msg = ugettext(u'Enter a valid email address.') raise djangoforms.ValidationError(msg, code='invalid') account = users.User(email_address) user_account = accounts.normalizeAccount(account) user = User.all().filter('account', user_account).get() if not user: raise djangoforms.ValidationError( "There is no user with that email address") self.cleaned_data['user'] = user q = GCIProfile.all() q.filter('program', self.request_data.program) q.ancestor(user) self.cleaned_data['profile'] = q.get()
def _getAllUsers(): """Returns a list of all valid users. """ from soc.models.user import User gen = lambda: User.all().filter('status =', 'valid') return interactive.deepFetch(gen)
class InviteForm(forms.ModelForm): """Django form for the invite page. """ link_id = djangoforms.CharField(label='Link ID/Email') class Meta: model = Request css_prefix = 'gsoc_intivation' fields = ['message'] def __init__(self, request_data, *args, **kwargs): super(InviteForm, self).__init__(*args, **kwargs) # store request object to cache results of queries self.request_data = request_data # reorder the fields so that link_id is the first one field = self.fields.pop('link_id') self.fields.insert(0, 'link_id', field) field.help_text = "The link_id or email address of the invitee" def clean_link_id(self): """Accepts link_id of users which may be invited. """ assert isSet(self.request_data.organization) invited_user = None link_id_cleaner = cleaning.clean_link_id('link_id') try: link_id = link_id_cleaner(self) except djangoforms.ValidationError, e: if e.code != 'invalid': raise email_cleaner = cleaning.clean_email('link_id') try: email_address = email_cleaner(self) except djangoforms.ValidationError, e: if e.code != 'invalid': raise msg = ugettext(u'Enter a valid link_id or email address.') raise djangoforms.ValidationError(msg, code='invalid') account = users.User(email_address) user_account = accounts.normalizeAccount(account) invited_user = User.all().filter('account', user_account).get() if not invited_user: raise djangoforms.ValidationError( "There is no user with that email address")
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 wrapped(self): """Decorator wrapper method. """ link_id = clean_link_id(field_name)(self) user_entity = User.get_by_key_name(link_id) if not user_entity: # user does not exist raise forms.ValidationError("This user does not exist.") return user_entity
def wrapped(self): """Decorator wrapper method. """ link_id = clean_link_id(field_name)(self) user_entity = User.get_by_key_name(link_id) if user_entity: # user exists already raise forms.ValidationError("There is already a user with this link id.") return link_id
def seed_survey_answer(request, i): """Returns the properties of a student's survey answers. """ ensureUser() survey = Survey.get_by_key_name('program/google/gsoc2009/survey_%d' % i) user = User.get_by_key_name('user_%d' % i) #student = GSoCStudent.get_by_key_name('google/gsoc2009/student_%d' % i) if not user: raise Error('Run seed_many for at least %d users first.' % i) if not survey: raise Error('Run seed_many for at least %d surveys first.' % i) all_properties = [] scope_path = 'google/gsoc2009/' checkbox = 'PickMultipleQ Checkbox 2 for survey_%d' % i # pylint: disable=E1103 for i in range(5): #student = GSoCStudent.get_by_key_name('google/gsoc2009/student_%d' % i) user = User.get_by_key_name('user_%d' % i) properties = { 'scope_path': scope_path, 'user': user, 'project': None, '_survey': survey, '_fields': { 'ShortQ': 'Test', 'SelectionQ': u'SelectionQ Option 2', 'LongQ': 'Long answer... \n' * 10, 'PickMultipleQ': checkbox, } } all_properties.append(properties) return all_properties
def clear(*args, **kwargs): """Removes all entities from the datastore. """ # there no explicit ranker model anywhere, so make one for # our own convenience to delete all rankers class ranker(db.Model): """ranker model used with ranklist module. """ pass # TODO(dbentley): If there are more than 1000 instances of any model, # this method will not clear all instances. Instead, it should continually # call .all(), delete all those, and loop until .all() is empty. entities = itertools.chain(*[ Notification.all(), GSoCMentor.all(), GHOPMentor.all(), GSoCStudent.all(), GHOPStudent.all(), Survey.all(), SurveyContent.all(), SurveyRecord.all(), GSoCOrgAdmin.all(), GHOPOrgAdmin.all(), ranker.all(), RankerRoot.all(), StudentProposal.all(), GSoCOrganization.all(), GHOPOrganization.all(), OrgApplication.all(), GSoCTimeline.all(), GHOPTimeline.all(), GSoCProgram.all(), GHOPProgram.all(), Host.all(), Sponsor.all(), User.all(), Site.all(), Document.all(), ]) try: for entity in entities: entity.delete() except db.Timeout: return http.HttpResponseRedirect('#') # pylint: disable-msg=E1101 memcache.flush_all() return http.HttpResponse('Done')
def forUserId(user_id): """Retrieves the user entity for the specified user id. If there is no user logged in, or they have no valid associated User entity, None is returned. """ if not user_id: raise base.InvalidArgumentError("Missing argument 'user_id'") q = User.all() q.filter('user_id', user_id) q.filter('status', 'valid') return q.get()
def clear(*args, **kwargs): """Removes all entities from the datastore. """ # there no explicit ranker model anywhere, so make one for # our own convenience to delete all rankers class ranker(db.Model): """ranker model used with ranklist module. """ pass # TODO(dbentley): If there are more than 1000 instances of any model, # this method will not clear all instances. Instead, it should continually # call .all(), delete all those, and loop until .all() is empty. entities = itertools.chain(*[ Notification.all(), GSoCMentor.all(), GCIMentor.all(), GSoCStudent.all(), GCIStudent.all(), Survey.all(), SurveyContent.all(), SurveyRecord.all(), GSoCOrgAdmin.all(), GCIOrgAdmin.all(), ranker.all(), RankerRoot.all(), StudentProposal.all(), GSoCOrganization.all(), GCIOrganization.all(), GSoCTimeline.all(), GCITimeline.all(), GSoCProgram.all(), GCIProgram.all(), Host.all(), Sponsor.all(), User.all(), Site.all(), Document.all(), ]) try: for entity in entities: entity.delete() except db.Timeout: return http.HttpResponseRedirect('#') # pylint: disable=E1101 memcache.flush_all() return http.HttpResponse('Done')
def seed_survey_answer(request, i): """Returns the properties of a student's survey answers. """ ensureUser() survey = Survey.get_by_key_name('program/google/gsoc2009/survey_%d' % i) user = User.get_by_key_name('user_%d' % i) #student = GSoCStudent.get_by_key_name('google/gsoc2009/student_%d' % i) if not user: raise Error('Run seed_many for at least %d users first.' % i) if not survey: raise Error('Run seed_many for at least %d surveys first.' % i) all_properties = [] scope_path = 'google/gsoc2009/' checkbox = 'PickMultipleQ Checkbox 2 for survey_%d' % i # pylint: disable=E1103 for i in range(5): #student = GSoCStudent.get_by_key_name('google/gsoc2009/student_%d' % i) user = User.get_by_key_name('user_%d' % i) properties = { 'scope_path': scope_path, 'user': user, 'project': None, '_survey': survey, '_fields': {'ShortQ':'Test', 'SelectionQ': u'SelectionQ Option 2', 'LongQ': 'Long answer... \n' * 10, 'PickMultipleQ': checkbox, } } all_properties.append(properties) return all_properties
def wrapped(self): """Decorator wrapper method. """ email_adress = self.cleaned_data.get(field_name).lower() # get the user account for this email and check if it's in use user_account = users.User(email_adress) user_entity = User.all().filter('account', user_account).get() if user_entity or user.isFormerAccount(user_account): raise forms.ValidationError("There is already a user " "with this email address.") return user_account
def convert(self, email, same_user_id=False): account = users.User(email=email) properties = { 'account': account, 'key_name': self.link_id, 'link_id': self.link_id, 'name': 'Test user', 'status': 'valid', } user = seeder_logic.seed(User, properties) if same_user_id: user = User.get_by_key_name(self.link_id) user.user_id = user.account.user_id() user.put() return convert_user.convert_user_txn(user.key())
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 seed_student_proposal(request, i): """Returns the properties of a new student proposal. """ ensureUser() org = GSoCOrganization.get_by_key_name('google/gsoc2009/org_%d' % i) mentor = GSoCMentor.get_by_key_name('google/gsoc2009/org_%d/mentor' % i) user = User.get_by_key_name('user_%d' % i) student = GSoCStudent.get_by_key_name('google/gsoc2009/student_%d' % i) if not user: raise Error('Run seed_many for at least %d users first.' % i) if not student: raise Error('Run seed_many for at least %d students first.' % i) if not org: raise Error('Run seed_many for at least %d orgs first.' % i) if not mentor: raise Error('Run seed_many for at least %d mentors first.' % i) all_properties = [] # pylint: disable=E1103 for i in range(random.randint(5, 20)): link_id = 'proposal_%s_%d' % (org.link_id, i) scope_path = 'google/gsoc2009/' + user.link_id properties = { 'link_id': link_id, 'scope_path': scope_path, 'scope': student, 'key_name': '%s/%s' % (scope_path, link_id), 'title': 'The Awesome Proposal %s %d' % (user.link_id, i), 'abstract': 'This is an Awesome Proposal, look at its awesomeness!', 'content': 'Sorry, too Awesome for you to read!', 'additional_info': 'http://www.zipit.com', 'mentor': mentor, 'status': 'pending', 'org': org, 'program': org.scope, } all_properties.append(properties) return all_properties
def forAccount(account): """Retrieves the user entity for the specified account. If there is no user logged in, or they have no valid associated User entity, None is returned. """ if not account: raise base.InvalidArgumentError("Missing argument 'account'") account = accounts.normalizeAccount(account) q = User.all() q.filter('account', account) q.filter('status', 'valid') return q.get()
def convertUser(user_key): """Converts the specified user by creating a new user entity that inherits from the newly added NewUser model. Args: user_key: User key. """ user = User.get(user_key) entity_id = user.key().name() account_id = user.user_id or 'unset' if user.status == 'valid': status = user_model.Status.ACTIVE elif user.status == 'invalid': status = user_model.Status.BANNED else: operation.counters.Increment('Bad status') logging.warning('Invalid status %s for user %s', user.status, user.key().name()) return host_for = [] for sponsor_key in user.host_for: host_for.extend( map( ndb.Key.from_old_key, GSoCProgram.all(keys_only=True).filter( 'sponsor', sponsor_key).fetch(1000))) host_for.extend( map( ndb.Key.from_old_key, GCIProgram.all(keys_only=True).filter( 'sponsor', sponsor_key).fetch(1000))) account = user.account new_user = NewUser(id=entity_id, account_id=account_id, status=status, host_for=host_for, account=account) _createUserTxn(new_user)
def clear(*args, **kwargs): """Removes all entities from the datastore. """ # TODO(dbentley): If there are more than 1000 instances of any model, # this method will not clear all instances. Instead, it should continually # call .all(), delete all those, and loop until .all() is empty. entities = itertools.chain(*[ Notification.all(), GCIStudent.all(), Survey.all(), SurveyRecord.all(), StudentProposal.all(), GSoCOrganization.all(), GCIOrganization.all(), GSoCTimeline.all(), GCITimeline.all(), GSoCProgram.all(), GSoCProfile.all(), GCIProfile.all(), GSoCProposal.all(), GCIProgram.all(), GCIScore.all(), GSoCStudentInfo.all(), GCIStudentInfo.all(), GCITask.all(), Host.all(), Sponsor.all(), User.all(), Site.all(), Document.all(), ]) try: for entity in entities: entity.delete() except db.Timeout: return http.HttpResponseRedirect('#') # pylint: disable=E1101 memcache.flush_all() return http.HttpResponse('Done')
def seed_student(request, i): """Returns the properties for a new student entity. """ gsoc2009 = GSoCProgram.get_by_key_name('google/gsoc2009') user = User.get_by_key_name('user_%d' % i) if not gsoc2009: raise Error('Run seed_db first') if not user: raise Error('Run seed_many for at least %d users first.' % i) properties = { 'key_name':'google/gsoc2009/student_%d' % i, 'link_id': 'student_%d' % i, 'scope_path': 'google/gsoc2009', 'scope': gsoc2009, 'user' : user, 'given_name': 'Student %d' % i, 'surname': 'Last Name', '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, 'school_name': 'School %d' % i, 'school_country': 'United States', 'major': 'Computer Science', 'degree': 'Undergraduate', 'expected_graduation': 2012, 'program_knowledge': 'Knowledge %d' % i, 'school': None, 'can_we_contact_you': True, } return properties
def seed_student(request, i): """Returns the properties for a new student entity. """ gsoc2009 = GSoCProgram.get_by_key_name('google/gsoc2009') user = User.get_by_key_name('user_%d' % i) if not gsoc2009: raise Error('Run seed_db first') if not user: raise Error('Run seed_many for at least %d users first.' % i) properties = { 'key_name': 'google/gsoc2009/student_%d' % i, 'link_id': 'student_%d' % i, 'scope_path': 'google/gsoc2009', 'scope': gsoc2009, 'user': user, 'given_name': 'Student %d' % i, 'surname': 'Last Name', '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, 'school_name': 'School %d' % i, 'school_country': 'United States', 'major': 'Computer Science', 'degree': 'Undergraduate', 'expected_graduation': 2012, 'program_knowledge': 'Knowledge %d' % i, 'school': None, 'can_we_contact_you': True, } return properties
def profileFromKwargs(self, profile_model): """Retrieves a profile from kwargs. Args: profile_model: The datastore model class """ key_name = self.data.kwargs['user'] self.data.url_user = User.get_by_key_name(key_name) if not self.data.url_user: raise NotFound('Requested user does not exist') fields = ['sponsor', 'program', 'user'] key_name = '/'.join(self.data.kwargs[i] for i in fields) self.data.url_profile = profile_model.get_by_key_name( key_name, parent=self.data.url_user) if not self.data.url_profile: raise NotFound('Requested user does not have a profile')
def convertUser(user_key): """Converts the specified user by creating a new user entity that inherits from the newly added NewUser model. Args: user_key: User key. """ user = User.get(user_key) entity_id = user.key().name() account_id = user.user_id or 'unset' if user.status == 'valid': status = user_model.Status.ACTIVE elif user.status == 'invalid': status = user_model.Status.BANNED else: operation.counters.Increment('Bad status') logging.warning( 'Invalid status %s for user %s', user.status, user.key().name()) return host_for = [] for sponsor_key in user.host_for: host_for.extend(map( ndb.Key.from_old_key, GSoCProgram.all(keys_only=True) .filter('sponsor', sponsor_key).fetch(1000))) host_for.extend(map( ndb.Key.from_old_key, GCIProgram.all(keys_only=True) .filter('sponsor', sponsor_key).fetch(1000))) account = user.account new_user = NewUser( id=entity_id, account_id=account_id, status=status, host_for=host_for, account=account) _createUserTxn(new_user)
def checkAccess(self): self.data.proposer_user = User.get_by_key_name( self.data.kwargs['student']) fields = ['sponsor', 'program', 'student'] key_name = '/'.join(self.data.kwargs[i] for i in fields) self.data.proposer_profile = GSoCProfile.get_by_key_name( key_name, parent=self.data.proposer_user) if not self.data.proposer_profile: raise NotFound('Requested user does not exist') self.data.proposal = GSoCProposal.get_by_id( int(self.data.kwargs['id']), parent=self.data.proposer_profile) if not self.data.proposal: raise NotFound('Requested proposal does not exist') self.data.proposal_org = self.data.proposal.org self.check.canAccessProposalEntity() self.mutator.commentVisible()
def checkAccess(self): self.data.proposer_user = User.get_by_key_name(self.data.kwargs['student']) fields = ['sponsor', 'program', 'student'] key_name = '/'.join(self.data.kwargs[i] for i in fields) self.data.proposer_profile = GSoCProfile.get_by_key_name( key_name, parent=self.data.proposer_user) if not self.data.proposer_profile: raise NotFound('Requested user does not exist') self.data.proposal = GSoCProposal.get_by_id( int(self.data.kwargs['id']), parent=self.data.proposer_profile) if not self.data.proposal: raise NotFound('Requested proposal does not exist') self.data.proposal_org = self.data.proposal.org self.check.canAccessProposalEntity() self.mutator.commentVisible()
def clean_email(self): email_cleaner = cleaning.clean_email("email") try: email_address = email_cleaner(self) except djangoforms.ValidationError as e: if e.code != "invalid": raise msg = ugettext(u"Enter a valid email address.") raise djangoforms.ValidationError(msg, code="invalid") account = users.User(email_address) user_account = accounts.normalizeAccount(account) user = User.all().filter("account", user_account).get() if not user: raise djangoforms.ValidationError("There is no user with that email address") self.cleaned_data["user"] = user q = GCIProfile.all() q.filter("program", self.request_data.program) q.ancestor(user) self.cleaned_data["profile"] = q.get()
def getHostsForProgram(program_entity, limit=1000): """Returns all the host entities for the given program. Args: program_entity: The Program entity for which the hosts must be determined Returns: The list of host entities for the specified program entity """ sponsor_key = Program.scope.get_value_for_datastore( program_entity) q = User.all() q.filter('host_for', sponsor_key) host_users = q.fetch(1000) # TODO(Madhu): to be simplified after host_for is moved from user entity # to host entity hosts = [] for user in host_users: q = Host.all() q.ancestor(user) hosts.append(q.get()) return hosts
def assertUserEqual(self, email): user = User.get_by_key_name(self.link_id) self.assertEqual(email, user.account.email()) self.assertTrue(user.account.user_id()) self.assertEqual(user.account.user_id(), user.user_id)
def isFormerAccount(account): """Returns true if account is a former account of some User. """ return User.all().filter('former_accounts', account).count() > 0
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')
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)