343 lines
10 KiB
Python
343 lines
10 KiB
Python
"""Provides factories for student models."""
|
|
|
|
|
|
from datetime import datetime
|
|
from uuid import uuid4
|
|
|
|
import factory
|
|
from django.contrib.auth.models import AnonymousUser, Group, Permission
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.test.client import RequestFactory
|
|
from factory.django import DjangoModelFactory
|
|
from opaque_keys.edx.keys import CourseKey
|
|
from pytz import UTC
|
|
|
|
from common.djangoapps.student.models import (
|
|
AccountRecovery,
|
|
CourseAccessRole,
|
|
CourseEnrollment,
|
|
CourseEnrollmentAllowed,
|
|
CourseEnrollmentAttribute,
|
|
CourseEnrollmentCelebration,
|
|
PendingEmailChange,
|
|
Registration,
|
|
User,
|
|
UserAttribute,
|
|
UserProfile,
|
|
UserStanding
|
|
)
|
|
from common.djangoapps.student.roles import GlobalStaff
|
|
from common.djangoapps.student.roles import CourseBetaTesterRole
|
|
from common.djangoapps.student.roles import CourseInstructorRole
|
|
from common.djangoapps.student.roles import CourseStaffRole
|
|
from common.djangoapps.student.roles import OrgInstructorRole
|
|
from common.djangoapps.student.roles import OrgStaffRole
|
|
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
|
|
from openedx.core.djangoapps.content.course_overviews.tests.factories import CourseOverviewFactory
|
|
|
|
TEST_PASSWORD = 'Password1234'
|
|
|
|
|
|
class GroupFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = Group
|
|
django_get_or_create = ('name', )
|
|
|
|
name = factory.Sequence('group{}'.format)
|
|
|
|
|
|
class UserStandingFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = UserStanding
|
|
|
|
user = None
|
|
account_status = None
|
|
changed_by = None
|
|
|
|
|
|
class UserProfileFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = UserProfile
|
|
django_get_or_create = ('user', )
|
|
|
|
user = None
|
|
name = factory.LazyAttribute('{0.user.first_name} {0.user.last_name}'.format)
|
|
level_of_education = None
|
|
gender = 'm'
|
|
mailing_address = None
|
|
goals = 'Learn a lot'
|
|
|
|
|
|
class RegistrationFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = Registration
|
|
|
|
user = None
|
|
activation_key = str(uuid4().hex)
|
|
|
|
|
|
class UserFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = User
|
|
django_get_or_create = ('email', 'username')
|
|
|
|
_DEFAULT_PASSWORD = 'Password1234'
|
|
|
|
username = factory.Sequence('robot{}'.format)
|
|
email = factory.Sequence('robot+test+{}@edx.org'.format)
|
|
password = factory.PostGenerationMethodCall('set_password', _DEFAULT_PASSWORD)
|
|
first_name = factory.Sequence('Robot{}'.format)
|
|
last_name = 'Test'
|
|
is_staff = False
|
|
is_active = True
|
|
is_superuser = False
|
|
last_login = datetime(2012, 1, 1, tzinfo=UTC)
|
|
date_joined = datetime(2011, 1, 1, tzinfo=UTC)
|
|
|
|
@factory.post_generation
|
|
def profile(obj, create, extracted, **kwargs): # pylint: disable=unused-argument, missing-function-docstring
|
|
if create:
|
|
obj.save()
|
|
return UserProfileFactory.create(user=obj, **kwargs)
|
|
elif kwargs:
|
|
raise Exception("Cannot build a user profile without saving the user")
|
|
else:
|
|
return None
|
|
|
|
@factory.post_generation
|
|
def groups(self, create, extracted, **kwargs): # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
|
|
if extracted is None:
|
|
return
|
|
|
|
if isinstance(extracted, str):
|
|
extracted = [extracted]
|
|
|
|
for group_name in extracted:
|
|
self.groups.add(GroupFactory.simple_generate(create, name=group_name)) # lint-amnesty, pylint: disable=no-member
|
|
|
|
|
|
class UserAttributeFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = UserAttribute
|
|
|
|
user = factory.SubFactory(UserFactory)
|
|
name = factory.Sequence('{}'.format)
|
|
value = factory.Sequence('{}'.format)
|
|
|
|
|
|
class RequestFactoryNoCsrf(RequestFactory):
|
|
"""
|
|
RequestFactory, which disables csrf checks.
|
|
"""
|
|
def request(self, **kwargs):
|
|
request = super().request(**kwargs)
|
|
setattr(request, '_dont_enforce_csrf_checks', True) # pylint: disable=literal-used-as-attribute
|
|
return request
|
|
|
|
|
|
class AnonymousUserFactory(factory.Factory):
|
|
class Meta:
|
|
model = AnonymousUser
|
|
|
|
|
|
class AdminFactory(UserFactory):
|
|
is_staff = True
|
|
|
|
|
|
class SuperuserFactory(UserFactory):
|
|
is_superuser = True
|
|
|
|
|
|
class CourseEnrollmentFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = CourseEnrollment
|
|
|
|
user = factory.SubFactory(UserFactory)
|
|
|
|
@classmethod
|
|
def _create(cls, model_class, *args, **kwargs):
|
|
manager = cls._get_manager(model_class)
|
|
course_kwargs = {}
|
|
for key in list(kwargs):
|
|
if key.startswith('course__'):
|
|
course_kwargs[key.split('__')[1]] = kwargs.pop(key)
|
|
|
|
if 'course' not in kwargs:
|
|
course_id = kwargs.get('course_id')
|
|
course_overview = None
|
|
if course_id is not None:
|
|
# 'course_id' is not needed by the model when course is passed.
|
|
# This arg used to be called course_id before we added the CourseOverview
|
|
# foreign key constraint to CourseEnrollment.
|
|
del kwargs['course_id']
|
|
|
|
if isinstance(course_id, str):
|
|
course_id = CourseKey.from_string(course_id)
|
|
course_kwargs.setdefault('id', course_id)
|
|
|
|
try:
|
|
course_overview = CourseOverview.get_from_id(course_id)
|
|
except CourseOverview.DoesNotExist:
|
|
pass
|
|
|
|
if course_overview is None:
|
|
if 'id' not in course_kwargs and course_id:
|
|
course_kwargs['id'] = course_id
|
|
|
|
course_overview = CourseOverviewFactory(**course_kwargs)
|
|
kwargs['course'] = course_overview
|
|
|
|
return manager.create(*args, **kwargs)
|
|
|
|
|
|
class CourseEnrollmentCelebrationFactory(DjangoModelFactory):
|
|
class Meta:
|
|
model = CourseEnrollmentCelebration
|
|
|
|
enrollment = factory.SubFactory(CourseEnrollmentFactory)
|
|
|
|
|
|
class CourseEnrollmentAttributeFactory(DjangoModelFactory):
|
|
class Meta:
|
|
model = CourseEnrollmentAttribute
|
|
|
|
enrollment = factory.SubFactory(CourseEnrollmentFactory)
|
|
|
|
|
|
class CourseAccessRoleFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = CourseAccessRole
|
|
|
|
user = factory.SubFactory(UserFactory)
|
|
course_id = CourseKey.from_string('edX/toy/2012_Fall')
|
|
role = 'TestRole'
|
|
|
|
|
|
class CourseEnrollmentAllowedFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = CourseEnrollmentAllowed
|
|
|
|
email = 'test@edx.org'
|
|
course_id = CourseKey.from_string('edX/toy/2012_Fall')
|
|
|
|
|
|
class PendingEmailChangeFactory(DjangoModelFactory):
|
|
"""Factory for PendingEmailChange objects
|
|
|
|
user: generated by UserFactory
|
|
new_email: sequence of new+email+{}@edx.org
|
|
activation_key: sequence of integers, padded to 30 characters
|
|
"""
|
|
class Meta:
|
|
model = PendingEmailChange
|
|
|
|
user = factory.SubFactory(UserFactory)
|
|
new_email = factory.Sequence('new+email+{}@edx.org'.format)
|
|
activation_key = factory.Sequence('{:0<30d}'.format)
|
|
|
|
|
|
class ContentTypeFactory(DjangoModelFactory):
|
|
class Meta:
|
|
model = ContentType
|
|
|
|
app_label = factory.Faker('app_name')
|
|
|
|
|
|
class PermissionFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = Permission
|
|
|
|
codename = factory.Faker('codename')
|
|
content_type = factory.SubFactory(ContentTypeFactory)
|
|
|
|
|
|
class AccountRecoveryFactory(DjangoModelFactory): # lint-amnesty, pylint: disable=missing-class-docstring
|
|
class Meta:
|
|
model = AccountRecovery
|
|
django_get_or_create = ('user',)
|
|
|
|
user = None
|
|
secondary_email = factory.Sequence('robot+test+recovery+{}@edx.org'.format)
|
|
is_active = True
|
|
|
|
|
|
class BetaTesterFactory(UserFactory):
|
|
"""
|
|
Given a course Location, returns a User object with beta-tester
|
|
permissions for `course`.
|
|
"""
|
|
last_name = 'Beta-Tester'
|
|
|
|
@factory.post_generation
|
|
def course_key(self, _create, extracted, **kwargs):
|
|
if extracted is None:
|
|
raise ValueError('Must specify a CourseKey for a beta-tester user')
|
|
CourseBetaTesterRole(extracted).add_users(self)
|
|
|
|
|
|
class GlobalStaffFactory(UserFactory):
|
|
"""
|
|
Returns a User object with global staff access
|
|
"""
|
|
last_name = 'GlobalStaff'
|
|
|
|
@factory.post_generation
|
|
def set_staff(self, _create, _extracted, **kwargs):
|
|
GlobalStaff().add_users(self)
|
|
|
|
|
|
class InstructorFactory(UserFactory):
|
|
"""
|
|
Given a course Location, returns a User object with instructor
|
|
permissions for `course`.
|
|
"""
|
|
last_name = 'Instructor'
|
|
|
|
@factory.post_generation
|
|
def course_key(self, _create, extracted, **kwargs):
|
|
if extracted is None:
|
|
raise ValueError('Must specify a CourseKey for a course instructor user')
|
|
CourseInstructorRole(extracted).add_users(self)
|
|
|
|
|
|
class OrgInstructorFactory(UserFactory):
|
|
"""
|
|
Given a course Location, returns a User object with org-instructor
|
|
permissions for `course`.
|
|
"""
|
|
last_name = 'Org-Instructor'
|
|
|
|
@factory.post_generation
|
|
def course_key(self, _create, extracted, **kwargs):
|
|
if extracted is None:
|
|
raise ValueError('Must specify a CourseKey for an org-instructor user')
|
|
OrgInstructorRole(extracted.org).add_users(self)
|
|
|
|
|
|
class OrgStaffFactory(UserFactory):
|
|
"""
|
|
Given a course Location, returns a User object with org-staff
|
|
permissions for `course`.
|
|
"""
|
|
last_name = 'Org-Staff'
|
|
|
|
@factory.post_generation
|
|
def course_key(self, _create, extracted, **kwargs):
|
|
if extracted is None:
|
|
raise ValueError('Must specify a CourseKey for an org-staff user')
|
|
OrgStaffRole(extracted.org).add_users(self)
|
|
|
|
|
|
class StaffFactory(UserFactory):
|
|
"""
|
|
Given a course Location, returns a User object with staff
|
|
permissions for `course`.
|
|
"""
|
|
last_name = 'Staff'
|
|
|
|
@factory.post_generation
|
|
def course_key(self, _create, extracted, **kwargs):
|
|
if extracted is None:
|
|
raise ValueError('Must specify a CourseKey for a course staff user')
|
|
CourseStaffRole(extracted).add_users(self)
|