def test_get_course_enrollments_for_site_exclude_same_user_different_site(
self):
"""
Test that CEs are not returned from course from another Site, in cases where a user has
CEs in desired Site, but also in another Site.
"""
course_overviews = [CourseOverviewFactory() for i in range(2)]
OrganizationCourseFactory(organization=self.organization,
course_id=str(course_overviews[0].id))
OrganizationCourseFactory(organization=self.default_site_org,
course_id=str(course_overviews[1].id))
uom_our_site = UserOrganizationMappingFactory(
organization=self.organization)
# enroll same user in a course associated w/ an Organization not connected to our Site
uom_other_site = UserOrganizationMappingFactory(
user=uom_our_site.user, organization=self.default_site_org)
CourseEnrollmentFactory(course_id=course_overviews[1].id,
user=uom_our_site.user)
expected_ce = [
CourseEnrollmentFactory(course_id=course_overviews[0].id,
user=uom_our_site.user)
]
course_enrollments = figures.sites.get_course_enrollments_for_site(
self.site)
assert set([ce.id for ce in course_enrollments
]) == set([ce.id for ce in expected_ce])
def setup(self, db, settings):
super(TestLearnerDetailsViewSetMultisite, self).setup(db)
# TODO:REFACTOR:Make base 'multisite scaffolding' view test class to
# set up the sites, orgs, and users. Put into tests/views/base.py
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
is_multisite = figures.helpers.is_multisite()
assert is_multisite
self.my_site_org = OrganizationFactory(sites=[self.site])
self.other_site = SiteFactory(domain='other-site.test')
self.other_site_org = OrganizationFactory(sites=[self.other_site])
self.my_course_overviews = [
CourseOverviewFactory() for i in range(0, 4)
]
for co in self.my_course_overviews:
OrganizationCourseFactory(organization=self.my_site_org,
course_id=str(co.id))
# Set up users and enrollments for 'my site'
self.my_site_users = [UserFactory() for i in range(3)]
for user in self.my_site_users:
UserOrganizationMappingFactory(user=user,
organization=self.my_site_org)
# Create a mix of enrollments:
# one learner in one course, same for the other, then two learners in
# the same course, and keep one course w/out learners
self.my_enrollments = [
CourseEnrollmentFactory(course=self.my_course_overviews[0],
user=self.my_site_users[0]),
CourseEnrollmentFactory(course=self.my_course_overviews[1],
user=self.my_site_users[1]),
CourseEnrollmentFactory(course=self.my_course_overviews[2],
user=self.my_site_users[0]),
CourseEnrollmentFactory(course=self.my_course_overviews[2],
user=self.my_site_users[1]),
]
self.caller = UserFactory()
UserOrganizationMappingFactory(user=self.caller,
organization=self.my_site_org,
is_amc_admin=True)
self.my_site_users.append(self.caller)
# Set up other site's data
self.other_site_enrollment = CourseEnrollmentFactory()
OrganizationCourseFactory(
organization=self.other_site_org,
course_id=self.other_site_enrollment.course.id)
UserOrganizationMappingFactory(user=self.other_site_enrollment.user,
organization=self.other_site_org)
self.expected_result_keys = [
'id', 'username', 'name', 'email', 'country', 'is_active',
'year_of_birth', 'level_of_education', 'gender', 'date_joined',
'bio', 'courses', 'language_proficiencies', 'profile_image'
]
def test_site_course_ids(monkeypatch):
site = SiteFactory()
course_overviews = [CourseOverviewFactory() for i in range(2)]
if organizations_support_sites():
monkeypatch.setattr('figures.sites.is_multisite', lambda: True)
our_org = OrganizationFactory(sites=[site])
# associate the course overviews with our org
for co in course_overviews:
OrganizationCourseFactory(course_id=co.id, organization=our_org)
other_org = OrganizationFactory(sites=[SiteFactory()])
# create a course associated with another org
co = CourseOverviewFactory()
OrganizationCourseFactory(course_id=co.id, organization=other_org)
course_ids = figures.sites.site_course_ids(site)
assert set(course_ids) == set([str(co.id) for co in course_overviews])
def course_test_data():
"""Temporary fixture. Will remove as we abstract testing
"""
months_back = 6
site = SiteFactory()
course_overview = CourseOverviewFactory()
if organizations_support_sites():
org = OrganizationFactory(sites=[site])
else:
org = OrganizationFactory()
OrganizationCourseFactory(organization=org,
course_id=str(course_overview.id))
enrollments = [
CourseEnrollmentFactory(course_id=course_overview.id) for i in range(3)
]
users = [enrollment.user for enrollment in enrollments]
student_modules = []
dates = generate_date_series(months_back=months_back)
assert dates
data_spec = list(zip(dates, list(range(months_back))))
return dict(
site=site,
org=org,
users=users,
course_overview=course_overview,
enrollments=enrollments,
student_modules=student_modules,
months_back=months_back,
dates=dates,
data_spec=data_spec,
)
def test_get_student_modules_for_course_in_site(self):
course_overviews = [CourseOverviewFactory() for i in range(3)]
for co in course_overviews[:-1]:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
assert get_user_model().objects.count() == 0
user = UserFactory()
UserOrganizationMappingFactory(user=user,
organization=self.organization)
sm_count = 2
sm_expected = [StudentModuleFactory(course_id=course_overviews[0].id,
student=user
) for i in range(sm_count)]
# StudentModule for other course
StudentModuleFactory(course_id=course_overviews[1].id)
# StudentModule for course not in organization
StudentModuleFactory(course_id=course_overviews[2].id)
sm = figures.sites.get_student_modules_for_course_in_site(
site=self.site, course_id=course_overviews[0].id)
assert sm.count() == len(sm_expected)
sm = figures.sites.get_student_modules_for_site(site=self.site)
assert sm.count() == len(sm_expected) + 1
def setup(self, db, settings):
# Set up data that's the same for standalone or multisite
self.date_for = utc_yesterday()
self.site = Site.objects.first()
self.courses = [CourseOverviewFactory(), CourseOverviewFactory()]
# Two for "our" course, one for another course in the same site
self.enrollments = [
CourseEnrollmentFactory(course_id=self.courses[0].id),
CourseEnrollmentFactory(course_id=self.courses[0].id),
CourseEnrollmentFactory(course_id=self.courses[1].id),
]
self.ce0_sm = StudentModuleFactory.from_course_enrollment(
self.enrollments[0],
created=as_datetime(self.date_for),
modified=as_datetime(self.date_for))
# Handle site mode specifices
if organizations_support_sites():
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
self.org = OrganizationFactory(sites=[self.site])
for course in self.courses:
OrganizationCourseFactory(organization=self.org,
course_id=str(course.id))
map_users_to_org(self.org, [ce.user for ce in self.enrollments])
# For our tests, we focus on a single enrollment. We should not
# need to stand up other site data, but if we find we do need to,
# then here's the place to do it
else:
self.org = OrganizationFactory()
def setup(self, db):
self.date_for = datetime.date(2018, 10, 1)
self.site = Site.objects.first()
self.users = [
UserFactory(date_joined=as_datetime(self.date_for -
datetime.timedelta(days=60)))
for i in range(0, 3)
]
self.course_overviews = [
CourseOverviewFactory(
created=as_datetime(self.date_for -
datetime.timedelta(days=60)))
for i in range(0, 3)
]
self.cdm_recs = [
CourseDailyMetricsFactory(site=self.site,
date_for=self.date_for,
**cdm) for cdm in CDM_INPUT_TEST_DATA
]
self.prev_day_sdm = SiteDailyMetricsFactory(site=self.site,
date_for=prev_day(
self.date_for),
**SDM_DATA[1])
if is_multisite():
self.organization = OrganizationFactory(sites=[self.site])
for co in self.course_overviews:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
if organizations_support_sites():
for user in self.users:
UserOrganizationMappingFactory(
user=user, organization=self.organization)
def sm_test_data(db):
"""
WIP StudentModule test data to test MAU
"""
year_for = 2019
month_for = 10
created_date = datetime(year_for, month_for, 1).replace(tzinfo=utc)
modified_date = datetime(year_for, month_for, 10).replace(tzinfo=utc)
course_overviews = [CourseOverviewFactory() for i in range(3)]
site = SiteFactory()
sm = []
for co in course_overviews:
sm += [StudentModuleFactory(course_id=co.id,
created=created_date,
modified=modified_date) for co in course_overviews]
if organizations_support_sites():
org = OrganizationFactory(sites=[site])
for co in course_overviews:
OrganizationCourseFactory(organization=org, course_id=str(co.id))
for rec in sm:
UserOrganizationMappingFactory(user=rec.student, organization=org)
else:
org = OrganizationFactory()
return dict(site=site,
organization=org,
course_overviews=course_overviews,
student_modules=sm,
year_for=year_for,
month_for=month_for)
def test_get_courses_for_site(self, course_count):
course_overviews = [CourseOverviewFactory() for i in range(course_count)]
for co in course_overviews:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
courses = figures.sites.get_courses_for_site(self.site)
expected_ids = [str(co.id) for co in course_overviews]
assert set([str(co.id) for co in courses]) == set(expected_ids)
def setup(self, db):
super(TestCoursesIndexViewSet, self).setup(db)
self.course_overviews = [make_course(**data) for data in COURSE_DATA]
if is_multisite():
self.organization = OrganizationFactory(sites=[self.site])
for co in self.course_overviews:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
def test_get_course_enrollments_for_site(self, ce_count):
course_overview = CourseOverviewFactory()
OrganizationCourseFactory(organization=self.organization,
course_id=str(course_overview.id))
expected_ce = [CourseEnrollmentFactory(
course_id=course_overview.id) for i in range(ce_count)]
course_enrollments = figures.sites.get_course_enrollments_for_site(self.site)
assert set([ce.id for ce in course_enrollments]) == set(
[ce.id for ce in expected_ce])
def setup(self, db):
self.date_for = DEFAULT_END_DATE
self.site = Site.objects.first()
self.course_count = 4
self.course_overviews = [CourseOverviewFactory(
created=self.date_for) for i in range(self.course_count)]
if is_multisite():
self.organization = OrganizationFactory(sites=[self.site])
for co in self.course_overviews:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
def simple_mau_test_data(settings):
"""
Pytest fixture to create the base test data we need for the MAU tests here
We set up single site vs multisite mode in this fixture based on which
edx-organizations package is declared in the pip requirements file used to
run the tests:
Community:
edx-organizations==0.4.10
Tahoe:
git+https://github.com/appsembler/[email protected]
"""
our_site = SiteFactory()
our_org = OrganizationFactory()
our_course = CourseOverviewFactory()
our_other_course = CourseOverviewFactory()
other_site = SiteFactory()
other_site_course = CourseOverviewFactory()
our_course_data = create_student_module_recs(our_course.id)
our_other_course_sm = [
StudentModuleFactory(course_id=our_other_course.id) for i in range(10)
]
month_for = date(year=our_course_data['year_for'],
month=our_course_data['month_for'],
day=1)
expected_mau_ids = set(
[rec.student.id for rec in our_course_data['in_range']])
test_data = dict(
month_for=month_for,
expected_mau_ids=expected_mau_ids,
our_site=our_site,
our_course=our_course,
our_course_data=our_course_data,
our_other_course=our_other_course,
our_other_course_sm=our_other_course_sm,
other_site=other_site,
other_site_course=other_site_course,
)
if organizations_support_sites():
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
our_org = OrganizationFactory(sites=[our_site])
for user in set([obj.student for obj in our_course_data['in_range']]):
UserOrganizationMappingFactory(user=user, organization=our_org)
for course_id in set(
[obj.course_id for obj in our_course_data['in_range']]):
OrganizationCourseFactory(organization=our_org,
course_id=str(course_id))
return test_data
def setup(self, db):
super(TestGeneralCourseDataViewSet, self).setup(db)
self.users = [make_user(**data) for data in USER_DATA]
self.course_overviews = [make_course(**data) for data in COURSE_DATA]
self.expected_result_keys = [
'course_id', 'course_name', 'course_code','org', 'start_date',
'end_date', 'self_paced', 'staff', 'metrics',
]
if is_multisite():
self.organization = OrganizationFactory(sites=[self.site])
for co in self.course_overviews:
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
def setup(self, db):
self.course_enrollments = [CourseEnrollmentFactory() for i in range(1, 5)]
if organizations_support_sites():
self.my_site = SiteFactory(domain='my-site.test')
self.my_site_org = OrganizationFactory(sites=[self.my_site])
for ce in self.course_enrollments:
OrganizationCourseFactory(organization=self.my_site_org,
course_id=str(ce.course.id))
UserOrganizationMappingFactory(user=ce.user,
organization=self.my_site_org)
self.student_module = StudentModuleFactory()
def setup(self, db):
self.today = datetime.date(2018, 6, 1)
self.course_overview = CourseOverviewFactory()
if OPENEDX_RELEASE == GINKGO:
self.course_enrollments = [
CourseEnrollmentFactory(course_id=self.course_overview.id)
for i in range(4)
]
else:
self.course_enrollments = [
CourseEnrollmentFactory(course=self.course_overview)
for i in range(4)
]
if organizations_support_sites():
self.my_site = SiteFactory(domain='my-site.test')
self.my_site_org = OrganizationFactory(sites=[self.my_site])
OrganizationCourseFactory(organization=self.my_site_org,
course_id=str(self.course_overview.id))
for ce in self.course_enrollments:
UserOrganizationMappingFactory(user=ce.user,
organization=self.my_site_org)
self.course_access_roles = [
CourseAccessRoleFactory(
user=self.course_enrollments[i].user,
course_id=self.course_enrollments[i].course_id,
role=role,
) for i, role in enumerate(self.COURSE_ROLES)
]
# create student modules for yesterday and today
for day in [prev_day(self.today), self.today]:
self.student_modules = [
StudentModuleFactory(course_id=ce.course_id,
student=ce.user,
created=ce.created,
modified=as_datetime(day))
for ce in self.course_enrollments
]
self.cert_days_to_complete = [10, 20, 30]
self.expected_avg_cert_days_to_complete = 20
self.generated_certificates = [
GeneratedCertificateFactory(
user=self.course_enrollments[i].user,
course_id=self.course_enrollments[i].course_id,
created_date=(self.course_enrollments[i].created +
datetime.timedelta(days=days)),
) for i, days in enumerate(self.cert_days_to_complete)
]
def cdm_test_data(db, settings):
"""Build CourseDailyMetrics data to test certificate counts
"""
our_site = SiteFactory()
mock_today = date(year=2020, month=6, day=7)
last_month = mock_today - relativedelta(months=1)
courses = [CourseOverviewFactory() for i in range(2)]
# Create data for previous month. Just need one record
# purpose is to make sure it is not included in our production code request
prev_month_cdm = [
CourseDailyMetrics(site=our_site,
course_id=str(courses[0].id),
date_for=last_month)
]
# Create data for our current month
curr_month_cdm = []
cdm_data = [
dict(day=1, course_id=str(courses[0].id), num_learners_completed=1),
dict(day=6, course_id=str(courses[0].id), num_learners_completed=10),
dict(day=1, course_id=str(courses[1].id), num_learners_completed=2),
dict(day=6, course_id=str(courses[1].id), num_learners_completed=20),
]
expected_cert_count = 30
for rec in cdm_data:
date_for = date(year=mock_today.year,
month=mock_today.month,
day=rec['day'])
cdm = CourseDailyMetricsFactory(
site=our_site,
course_id=rec['course_id'],
date_for=date_for,
num_learners_completed=rec['num_learners_completed'])
curr_month_cdm.append(cdm)
if organizations_support_sites():
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
our_org = OrganizationFactory(sites=[our_site])
for course in courses:
OrganizationCourseFactory(organization=our_org,
course_id=str(course.id))
return dict(
mock_today=mock_today,
our_site=our_site,
courses=courses,
prev_month_cdm=prev_month_cdm,
curr_month_cdm=curr_month_cdm,
expected_cert_count=expected_cert_count,
)
def test_get_site_for_courses(self):
"""
Can we get the site for a given course?
We shouldn't care what the other site is. For reference, it is the
default site with 'example.com' for both the domain and name fields
"""
# We want to move the patch to the class level if possible
co = CourseOverviewFactory()
OrganizationCourseFactory(organization=self.organization,
course_id=str(co.id))
site = figures.sites.get_site_for_course(str(co.id))
assert site == self.site
def sog_data():
"""Fixture to create site, organization, and course overview
This fixture exists mostly to help abstract multisite handing from tests
Returns a dict of 'site', 'organization', and 'course_overview' objects
"""
site = SiteFactory()
course_overview = CourseOverviewFactory()
if organizations_support_sites():
organization = OrganizationFactory(sites=[site])
else:
organization = OrganizationFactory()
OrganizationCourseFactory(organization=organization,
course_id=str(course_overview.id))
return dict(site=site,
organization=organization,
course_overview=course_overview)
def setup(self, db):
super(TestCourseEnrollmentViewSet, self).setup(db)
self.special_fields = (
'create',
'user',
)
self.course_overview = CourseOverviewFactory()
self.course_enrollments = [
CourseEnrollmentFactory(course_id=self.course_overview.id)
for i in range(1, 5)
]
self.sample_course_id = self.course_enrollments[0].course_id
if is_multisite():
self.organization = OrganizationFactory(sites=[self.site])
OrganizationCourseFactory(organization=self.organization,
course_id=str(self.course_overview.id))
def test_get_course_in_other_site(self, monkeypatch):
"""
This test is broken. Needs review of django.contrib.sites handling for
`get_current_site`
"""
with mock.patch('figures.helpers.settings.FEATURES',
{'FIGURES_IS_MULTISITE': True}):
assert figures.helpers.is_multisite()
# Stand up site specific data. Candidate for a fixture
alpha_site = SiteFactory(domain='alpha.site')
alpha_org = OrganizationFactory(sites=[alpha_site])
alpha_course = CourseOverviewFactory(org=alpha_org.short_name)
OrganizationCourseFactory(organization=alpha_org,
course_id=str(alpha_course.id))
alpha_admin_user = UserFactory(username='******')
UserOrganizationMappingFactory(user=alpha_admin_user,
organization=alpha_org,
is_amc_admin=True)
bravo_site = SiteFactory(domain='bravo.site')
bravo_org = OrganizationFactory(sites=[bravo_site])
bravo_admin_user = UserFactory(username='******')
UserOrganizationMappingFactory(user=bravo_admin_user,
organization=bravo_org,
is_amc_admin=True)
# Run rest of test
request = APIRequestFactory().get(self.request_path)
request.META['HTTP_HOST'] = alpha_site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts,
'get_current_site', lambda req: alpha_site)
force_authenticate(request, user=alpha_admin_user)
view = self.view_class.as_view({'get': 'retrieve'})
response = view(request, pk=str(alpha_course.id))
assert response.status_code == 200, 'user=alpha_admin_user'
monkeypatch.setattr(django.contrib.sites.shortcuts,
'get_current_site', lambda req: bravo_site)
force_authenticate(request, user=bravo_admin_user)
view = self.view_class.as_view({'get': 'retrieve'})
response = view(request, pk=str(alpha_course.id))
assert response.status_code == 403, 'user=bravo_admin_user'
def backfill_test_data(db):
"""
TODO: make counts different for each course per month
"""
months_back = 6
sm_per_month = [10 + i for i in range(months_back + 1)]
site = SiteFactory()
now = datetime.utcnow().replace(tzinfo=utc)
first_month = now - relativedelta(months=months_back)
last_month = now - relativedelta(months=1)
course_overviews = [CourseOverviewFactory() for i in range(1)]
count_check = []
sm = []
for i, dt in enumerate(
rrule(freq=MONTHLY, dtstart=first_month, until=last_month)):
for co in course_overviews:
sm_count = sm_per_month[i]
month_sm = [
StudentModuleFactory(course_id=co.id, created=dt, modified=dt)
for i in range(sm_count)
]
sm += month_sm
count_check.append(dict(month=dt, month_sm=month_sm,
sm_count=sm_count))
if organizations_support_sites():
org = OrganizationFactory(sites=[site])
for co in course_overviews:
OrganizationCourseFactory(organization=org, course_id=str(co.id))
for rec in sm:
UserOrganizationMappingFactory(user=rec.student, organization=org)
else:
org = OrganizationFactory()
return dict(site=site,
organization=org,
course_overview=course_overviews,
student_modules=sm,
first_month=first_month,
now=now,
months_back=months_back,
sm_per_month=sm_per_month,
count_check=count_check)
def setup(self, db):
self.today = date.today()
self.site = SiteFactory()
if organizations_support_sites():
self.org = OrganizationFactory(sites=[self.site])
else:
self.org = OrganizationFactory()
self.datetime_1 = datetime(2020, 2, 2, tzinfo=utc)
self.datetime_2 = self.datetime_1 + relativedelta(
months=1) # future of date_1
self.course_overview = CourseOverviewFactory()
self.course_enrollment = CourseEnrollmentFactory(
course_id=self.course_overview.id)
self.course_enrollment_2 = CourseEnrollmentFactory(
course_id=self.course_overview.id)
if organizations_support_sites():
OrganizationCourseFactory(organization=self.org,
course_id=str(self.course_overview.id))
UserOrganizationMappingFactory(organization=self.org,
user=self.course_enrollment.user)
UserOrganizationMappingFactory(organization=self.org,
user=self.course_enrollment_2.user)
self.student_modules = [
StudentModuleFactory(student=self.course_enrollment.user,
course_id=self.course_enrollment.course_id,
modified=self.datetime_1),
StudentModuleFactory(student=self.course_enrollment.user,
course_id=self.course_enrollment.course_id,
modified=self.datetime_2),
# This student module does not belong to the user in course_enrollment
StudentModuleFactory(course_id=self.course_enrollment.course_id,
modified=self.datetime_2)
]
self.learner_sm = StudentModule.objects.filter(
course_id=self.course_enrollment.course_id,
student=self.course_enrollment.user).order_by('-modified')
self.progress_data = dict(points_possible=100,
points_earned=25,
sections_worked=4,
count=5)
def test_get_active_users_for_time_period(self):
'''
'''
assert figures.helpers.is_multisite()
student_module_sets = []
for i in range(0, 3):
data = create_student_module_test_data(
start_date=self.data_start_date, end_date=self.data_end_date)
student_module_sets.append(data)
OrganizationCourseFactory(organization=self.alpha_org,
course_id=str(
data['course_overview'].id))
UserOrganizationMappingFactory(user=data['user'],
organization=self.alpha_org)
count = get_active_users_for_time_period(
site=self.alpha_site,
start_date=self.data_start_date,
end_date=self.data_end_date)
assert count == len(student_module_sets)
def make_site_data(num_users=3, num_courses=2):
"""
This is a copy-n-paste hack from figures/tests/conftest.py
"""
site = SiteFactory()
if organizations_support_sites():
org = OrganizationFactory(sites=[site])
else:
org = OrganizationFactory()
courses = [CourseOverviewFactory() for i in range(num_courses)]
users = [UserFactory() for i in range(num_users)]
enrollments = []
users = [UserFactory() for i in range(num_users)]
enrollments = []
for i, user in enumerate(users):
# Create increasing number of enrollments for each user, maximum to one less
# than the number of courses
for j in range(i):
enrollments.append(
CourseEnrollmentFactory(course=courses[j - 1], user=user))
if organizations_support_sites():
for course in courses:
OrganizationCourseFactory(organization=org,
course_id=str(course.id))
# Set up user mappings
map_users_to_org(org, users)
return dict(
site=site,
org=org,
courses=courses,
users=users,
enrollments=enrollments,
)
def test_get_site_mau_current_month(db):
mock_today = date(year=2020, month=3, day=1)
freezer = freeze_time(mock_today)
freezer.start()
start_dt = datetime(mock_today.year,
mock_today.month,
1,
tzinfo=fuzzy.compat.UTC)
end_dt = datetime(mock_today.year,
mock_today.month,
31,
tzinfo=fuzzy.compat.UTC)
date_gen = fuzzy.FuzzyDateTime(start_dt=start_dt, end_dt=end_dt)
site = SiteFactory()
course_overviews = [CourseOverviewFactory() for i in range(2)]
users = [UserFactory() for i in range(2)]
sm = []
for user in users:
for co in course_overviews:
sm.append(
StudentModuleFactory(course_id=co.id,
student=user,
modified=date_gen.evaluate(
2, None, False)))
if organizations_support_sites():
org = OrganizationFactory(sites=[site])
for co in course_overviews:
OrganizationCourseFactory(organization=org, course_id=str(co.id))
for user in users:
UserOrganizationMappingFactory(user=user, organization=org)
active_user_count = get_site_mau_current_month(site)
freezer.stop()
assert active_user_count == len(users)