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_registered_learners(self, monkeypatch, user_reg_test_data):
"""
Example response data:
{'registered_users': {'current_month': 20,
'history': [
{'period': '2019/08', 'value': 3},
{'period': '2019/09', 'value': 4},
{'period': '2019/10', 'value': 7},
{'period': '2019/11', 'value': 11},
{'period': '2019/12', 'value': 20},
{'period': '2020/01', 'value': 20},
{'period': '2020/02', 'value': 20}]}}
"""
request_method = 'get'
endpoint = 'registered_users'
site = user_reg_test_data['site']
users = user_reg_test_data['users']
dates = user_reg_test_data['dates']
months_back = user_reg_test_data['months_back']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=users)
else:
caller = UserFactory(is_staff=True)
request = APIRequestFactory().get(self.request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({request_method: endpoint})
response = view(request)
assert self.check_response(response=response, endpoint=endpoint)
def test_active_users(self, monkeypatch, user_reg_test_data):
endpoint = 'active_users'
request_method = 'get'
site = user_reg_test_data['site']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=[])
else:
caller = UserFactory(is_staff=True)
expected_response = 'active_users history metric data'
monkeypatch.setattr(
'figures.views.metrics.get_site_mau_history_metrics',
lambda **_kwargs: expected_response)
request = APIRequestFactory().get(self.request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({request_method: endpoint})
response = view(request)
assert response.data['active_users'] == expected_response
def test_avg_progress(self, monkeypatch, sog_data):
site = sog_data['site']
course_overview = sog_data['course_overview']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=[])
else:
caller = UserFactory(is_staff=True)
expected_response = 'avg_progress history metric data'
def mock_get_course_history_metric(**kwargs):
return expected_response
monkeypatch.setattr('figures.views.get_course_history_metric',
mock_get_course_history_metric)
request_path = self.base_request_path + str(
course_overview.id) + '/avg_progress/'
request = APIRequestFactory().get(request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({'get': 'avg_progress'})
response = view(request, pk=str(course_overview.id))
assert response.status_code == status.HTTP_200_OK
assert response.data['avg_progress'] == expected_response
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 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 test_no_update_has_lcgm_no_sm(self, monkeypatch):
"""We have an LCGM but not an SM record
The function under test should return the existing LCGM
"""
monkeypatch.setattr(
'figures.pipeline.enrollment_metrics.get_site_for_course',
lambda val: self.site)
monkeypatch.setattr(
'figures.pipeline.enrollment_metrics._collect_progress_data',
lambda val: self.progress_data)
# Create a course enrollment for which we won't have student module records
ce = CourseEnrollmentFactory(
course_id=self.course_enrollment.course_id)
if organizations_support_sites():
UserOrganizationMappingFactory(organization=self.org, user=ce.user)
lcgm = LearnerCourseGradeMetricsFactory(course_id=ce.course_id,
user=ce.user)
ce_sm = StudentModule.objects.filter(course_id=ce.course_id,
student_id=ce.user.id)
assert not ce_sm
metrics = collect_metrics_for_enrollment(site=self.site,
course_enrollment=ce,
date_for=self.today,
student_modules=ce_sm)
assert not metrics
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 make_caller(self, site, users):
"""Convenience method to create the API caller user
"""
if organizations_support_sites():
# TODO: set is_staff to False after we have test coverage
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=users)
else:
caller = UserFactory(is_staff=True)
return caller
def setup(self, db):
super(TestUserIndexViewSet, self).setup(db)
self.users = [make_user(**data) for data in USER_DATA]
self.usernames = [data['username'] for data in USER_DATA]
self.expected_result_keys = ['id', 'username', 'fullname']
if organizations_support_sites():
self.organization = OrganizationFactory(sites=[self.site])
for user in self.users:
UserOrganizationMappingFactory(user=user,
organization=self.organization)
assert len(self.users) == len(USER_DATA)
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 make_caller(org):
"""Convenience method to create the API caller user
"""
if organizations_support_sites():
# TODO: set is_staff to False after we have test coverage
caller = UserFactory(is_staff=True)
UserOrganizationMappingFactory(user=caller,
organization=org,
is_amc_admin=True)
else:
caller = UserFactory(is_staff=True)
return caller
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):
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 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 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 lm_test_data(db, settings):
"""Learner Metrics Test Data
user0 not enrolled in any courses
user1 enrolled in 1 course
user2 enrolled in 2 courses
"""
if organizations_support_sites():
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
our_site_data = make_site_data()
other_site_data = make_site_data()
return dict(us=our_site_data, them=other_site_data)
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 site_data(db, settings):
"""Simple fake site data
"""
if organizations_support_sites():
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
site_data = make_site_data()
ce = site_data['enrollments'][0]
lcgm = [
LearnerCourseGradeMetricsFactory(site=site_data['site'],
user=ce.user,
course_id=str(ce.course_id),
date_for='2020-10-01'),
]
site_data['lcgm'] = lcgm
return site_data
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 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 test_list(self, monkeypatch, sm_test_data):
site = sm_test_data['site']
org = sm_test_data['organization']
if organizations_support_sites():
caller = UserFactory()
UserOrganizationMappingFactory(user=caller,
organization=org,
is_amc_admin=True)
else:
caller = UserFactory(is_staff=True)
request = APIRequestFactory().get(self.request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({'get': 'list'})
response = view(request)
assert response.status_code == status.HTTP_200_OK
def test_retrieve_method(self, monkeypatch, course_test_data):
site = course_test_data['site']
users = course_test_data['users']
course_overview = course_test_data['course_overview']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=users)
else:
caller = UserFactory(is_staff=True)
request_path = self.base_request_path
request = APIRequestFactory().get(request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({'get': 'retrieve'})
response = view(request, pk=str(course_overview.id))
assert response.status_code == status.HTTP_200_OK
def test_retrieve_invalid_course_id(self, monkeypatch, course_test_data,
invalid_course_id):
"""Tests that invalid course ids return '404 NOT FOUND'
"""
site = course_test_data['site']
users = course_test_data['users']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=users)
else:
caller = UserFactory(is_staff=True)
request_path = self.base_request_path
request = APIRequestFactory().get(request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({'get': 'retrieve'})
response = view(request, pk=invalid_course_id)
assert response.status_code == status.HTTP_404_NOT_FOUND
def test_site_courses(self, monkeypatch, user_reg_test_data):
endpoint = 'site_courses'
request_method = 'get'
site = user_reg_test_data['site']
users = user_reg_test_data['users']
dates = user_reg_test_data['dates']
months_back = user_reg_test_data['months_back']
if organizations_support_sites():
caller = UserFactory(is_staff=True)
map_users_to_org_site(caller=caller, site=site, users=users)
else:
caller = UserFactory(is_staff=True)
request = APIRequestFactory().get(self.request_path)
request.META['HTTP_HOST'] = site.domain
monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site',
lambda req: site)
force_authenticate(request, user=caller)
view = self.view_class.as_view({request_method: endpoint})
response = view(request)
assert self.check_response(response=response, endpoint=endpoint)
def test_student_modules_for_course_enrollment(monkeypatch):
"""Test we get the correct student modules for the given course enrollment
"""
site = SiteFactory()
ce = CourseEnrollmentFactory()
ce_sm = [StudentModuleFactory(student=ce.user, course_id=ce.course_id)]
# Create another student module record to make sure this is not in our
# query results
StudentModuleFactory()
if organizations_support_sites():
monkeypatch.setattr('figures.sites.is_multisite', lambda: True)
our_org = OrganizationFactory(sites=[site])
other_org = OrganizationFactory(sites=[SiteFactory()])
other_org_ce = CourseEnrollmentFactory()
other_sm = StudentModuleFactory(student=other_org_ce.user,
course_id=other_org_ce.course_id)
UserOrganizationMappingFactory(user=ce.user, organization=our_org)
UserOrganizationMappingFactory(user=other_org_ce.user,
organization=other_org)
sm = figures.sites.student_modules_for_course_enrollment(site, ce)
assert set(sm) == set(ce_sm)
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)
save_course_mau,
collect_course_mau,
)
from tests.factories import (
SiteFactory,
CourseOverviewFactory,
OrganizationFactory,
OrganizationCourseFactory,
StudentModuleFactory,
)
from tests.helpers import organizations_support_sites
from six.moves import range
if organizations_support_sites():
from tests.factories import UserOrganizationMappingFactory
def create_student_module_recs(course_id):
"""
Create StudentModule records for our test data
We create records within the test month and before and after our test month
Improve this by passing the year and month for which we want to check
record inclusion and deriving dates outside of our month range for the
StudentModule records we want to exclude
"""
# Create SM in our month
year_for = 2020
month_for = 1
import figures.helpers
import figures.sites
from tests.factories import (
CourseEnrollmentFactory,
CourseOverviewFactory,
OrganizationFactory,
OrganizationCourseFactory,
SiteFactory,
StudentModuleFactory,
UserFactory,
)
from tests.helpers import organizations_support_sites
if organizations_support_sites():
from tests.factories import UserOrganizationMappingFactory
@pytest.mark.django_db
class TestHandlersForStandaloneMode(object):
"""
Tests figures.sites site handling functions in standalone site mode
These tests should pass regardless of whether or not and if so how
organizations supports organization-site mapping
"""
@pytest.fixture(autouse=True)
def setup(self, db, settings):
settings.FEATURES['FIGURES_IS_MULTISITE'] = False
is_multisite = figures.helpers.is_multisite()
assert not is_multisite