def setup(self, db, settings):
"""
TODO: rework this so we have a top level object as a dict, then we can
swap the sites in and out to test inclusion and exclusion
"""
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
is_multisite = figures.helpers.is_multisite()
assert is_multisite
self.data_start_date = DEFAULT_START_DATE
self.data_end_date = DEFAULT_END_DATE
self.alpha_site = SiteFactory(domain='alpha.site')
self.alpha_course_overview = CourseOverviewFactory()
self.alpha_course_daily_metrics = create_course_daily_metrics_data(
site=self.alpha_site,
start_date=self.data_start_date,
end_date=self.data_end_date,
course_id=self.alpha_course_overview.id)
self.bravo_site = SiteFactory(domain='bravo.site')
self.bravo_course_overview = CourseOverviewFactory()
self.bravo_course_daily_metrics = create_course_daily_metrics_data(
site=self.bravo_site,
start_date=self.data_start_date,
end_date=self.data_end_date,
course_id=self.bravo_course_overview.id)
def test_site(self):
"""
Tests expected CourseDailyMetrics behavior for working with a Site
"""
assert Site.objects.count() == 1
rec_data = dict(
site=self.site,
date_for=datetime.date(2018, 2, 2),
enrollment_count=11,
active_learners_today=1,
average_progress=0.5,
average_days_to_complete=5,
num_learners_completed=10
)
rec = rec_data.copy()
rec['course_id'] = 'course-v1:SomeOrg+ABC01+2121'
obj = CourseDailyMetrics.objects.create(**rec)
assert obj.site == Site.objects.first()
rec['course_id'] = 'course-v1:AlphaOrg+ABC01+2121'
alpha_site = SiteFactory(domain='alpha.example.com', name='Alpha')
assert Site.objects.count() == 2
rec['site'] = alpha_site
obj2 = CourseDailyMetrics.objects.create(**rec)
assert obj2.site == alpha_site
# Test cascade delete
assert CourseDailyMetrics.objects.count() == 2
alpha_site.delete()
assert CourseDailyMetrics.objects.count() == 1
# Verify we deleted the correct metrics object
assert obj == CourseDailyMetrics.objects.first()
def test_multiple_sites(self):
"""
Tests expected SiteDailyMetrics behavior for working with a Site
"""
assert Site.objects.count() == 1
default_site = Site.objects.first()
rec = dict(
site=Site.objects.first(),
date_for=datetime.date(2018, 02, 02),
cumulative_active_user_count=11,
total_user_count=1,
course_count=1,
total_enrollment_count=1
)
obj = SiteDailyMetrics.objects.create(**rec)
assert obj.site == default_site
alpha_site = SiteFactory(domain='alpha.example.com', name='Alpha')
assert Site.objects.count() == 2
rec['site'] = alpha_site
obj2 = SiteDailyMetrics.objects.create(**rec)
assert obj2.site == alpha_site
# Test cascade delete
assert SiteDailyMetrics.objects.count() == 2
alpha_site.delete()
assert SiteDailyMetrics.objects.count() == 1
# Verify we deleted the correct metrics object
assert obj == SiteDailyMetrics.objects.first()
def test_two_sites(self):
site = SiteFactory.create(
root_page=PageFactory.create(title='mypage', path='00010002'))
site_b = SiteFactory.create(
root_page=PageFactory.create(title='mypage', path='00010003'))
SystemStringFactory.create(
identifier='headline',
string='headline a',
site=site,
)
SystemStringFactory.create(
identifier='headline',
string='headline b',
site=site_b,
)
fill_cache(site)
fill_cache(site_b)
preload(site)
preload(site_b)
set_site(site)
self.assertEquals(gettext('headline'), 'headline a')
set_site(site_b)
self.assertEquals(gettext('headline'), 'headline b')
def setUp(self):
"""There should be an existing site with domain and name of u'example.com'
"""
assert Site.objects.count() == 1
self.sites = [
Site.objects.first(),
SiteFactory(domain=u'alpha.test.site', name=u'Alpha'),
SiteFactory(domain=u'bravo.test.site', name=u'Bravo Organization'),
]
def test_backfill_daily_with_site_domain(self):
"""Test that proper site id gets passed to task func when passing integer."""
SiteFactory.reset_sequence(0)
site2 = SiteFactory() # site-0.example.com
with mock.patch(self.PLAIN_PATH) as mock_populate:
call_command('backfill_figures_daily_metrics',
site="site-0.example.com",
no_delay=True)
assert mock_populate.called_with(site_id=2)
def setup(self, db):
super(TestSiteViewSet, self).setup(db)
assert Site.objects.count() == 1
self.sites = [
Site.objects.first(),
SiteFactory(domain=u'alpha.test.site', name=u'Alpha Group'),
SiteFactory(domain=u'bravo.test.site', name=u'Bravo Organization'),
]
self.expected_result_keys = ['id', 'domain', 'name']
def sdm_test_data(db):
"""Quick-n-dirty test data construction
Expected count is the highest 'total_user_count'
"""
dates = [
datetime(year=2020, month=3, day=15),
datetime(year=2020, month=4, day=1),
datetime(year=2020, month=4, day=15),
datetime(year=2020, month=4, day=30),
datetime(year=2020, month=5, day=1)
]
our_date_range = [
datetime(year=2020, month=4, day=1),
datetime(year=2020, month=4, day=30),
]
my_site = SiteFactory()
other_site = SiteFactory()
my_sdm = [
# month before
SiteDailyMetricsFactory(site=my_site,
date_for=dates[0],
total_user_count=10),
# in our date range
SiteDailyMetricsFactory(site=my_site,
date_for=dates[1],
total_user_count=20),
SiteDailyMetricsFactory(site=my_site,
date_for=dates[2],
total_user_count=30),
SiteDailyMetricsFactory(site=my_site,
date_for=dates[3],
total_user_count=25),
# month after
SiteDailyMetricsFactory(site=my_site,
date_for=dates[4],
total_user_count=500),
]
# Create one SDM record for the other site in the month we query
other_sdm = [
SiteDailyMetricsFactory(site=other_site,
date_for=dates[2],
total_user_count=13)]
return dict(
our_date_range=our_date_range,
my_site=my_site,
other_site=other_site,
my_sdm=my_sdm,
other_sdm=other_sdm,
expected_count=30,
)
def test_get_site_mau_history_metrics_basic(db, monkeypatch):
"""Simple data, skipping doing a fixture for now
Expected data:
{'current_month': 12,
'history': [{'period': '2019/12', 'value': 6},
{'period': '2020/01', 'value': 7},
{'period': '2020/02', 'value': 8},
{'period': '2020/03', 'value': 9},
{'period': '2020/04', 'value': 10},
{'period': '2020/05', 'value': 11},
{'period': '2020/06', 'value': 12}]}
TODO: We want to revisit both this test and the function under test
"""
all_months_back = 12
months_back = 6
mock_today = date(year=2020, month=6, day=1)
last_month = mock_today - relativedelta(months=1)
freezer = freeze_time(mock_today)
freezer.start()
start_month = mock_today - relativedelta(months=all_months_back)
smm = []
our_site = SiteFactory()
other_site = SiteFactory()
for site in [our_site, other_site]:
for counter, dt in enumerate(
rrule(freq=MONTHLY, dtstart=start_month, until=last_month)):
month_for = date(year=dt.year, month=dt.month, day=1)
smm.append(
SiteMonthlyMetricsFactory(site=site,
month_for=month_for,
active_user_count=counter))
current_month_active = 42
SiteDailyMetricsFactory(site=our_site,
date_for=mock_today - relativedelta(day=2),
mau=current_month_active)
data = get_site_mau_history_metrics(site=our_site, months_back=months_back)
freezer.stop()
assert data['current_month'] == current_month_active
for rec in data['history'][:-1]:
year, month = [int(val) for val in rec['period'].split('/')]
month_for = date(year=year, month=month, day=1)
obj = SiteMonthlyMetrics.objects.get(site=our_site,
month_for=month_for)
assert obj.active_user_count == rec['value']
assert obj.site == our_site
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 test_get_side_ids(self, site, expected_result):
"""Test that get_site_ids will return the correct Site id if passed that id
or the corresponding Site's domain, will return all Site ids if none passed,
and will return an empty list if a non-existing Site id or domain passed
"""
# Site table will have an existing example.com Site as well as whatever we
# create w/ SiteFactory, due to data migration
example_site = Site.objects.get(domain='example.com')
SiteFactory.reset_sequence(0)
site1 = SiteFactory() # site-0.example.com
site2 = SiteFactory() # site-1.example.com
with mock.patch('figures.management.base.get_sites') as mock_get_sites:
mock_get_sites.return_value = [example_site, site1, site2]
site_ids = BaseBackfillCommand().get_site_ids(site)
assert site_ids == expected_result
def test_populate_course_mau(transactional_db, monkeypatch):
expected_site = SiteFactory()
course = CourseOverviewFactory()
def mock_collect_course_mau(site,
courselike,
month_for=None,
overwrite=False):
assert site == expected_site
assert courselike
assert isinstance(month_for, date)
return CourseMauMetricsFactory(), True
monkeypatch.setattr('figures.tasks.collect_course_mau',
mock_collect_course_mau)
figures.tasks.populate_course_mau(site_id=expected_site.id,
course_id=str(course.id))
# TODO: Create own test function
figures.tasks.populate_course_mau(site_id=expected_site.id,
course_id=str(course.id),
month_for=None)
figures.tasks.populate_course_mau(site_id=expected_site.id,
course_id=str(course.id),
month_for='2020-1-1')
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_course_param_multiple(self, monkeypatch, enrollment_test_data):
"""Test that the 'course' query parameter works
"""
site = enrollment_test_data['site']
users = enrollment_test_data['users']
enrollments = enrollment_test_data['enrollments']
course_overviews = enrollment_test_data['course_overviews']
caller = self.make_caller(site, users)
other_site = SiteFactory()
assert site.domain != other_site.domain
assert len(course_overviews) > 1
query_params = '?course={}&course={}'.format(
str(course_overviews[0].id), str(course_overviews[1].id))
request_path = self.base_request_path + query_params
response = self.make_request(request_path=request_path,
monkeypatch=monkeypatch,
site=site,
caller=caller,
action='list')
assert response.status_code == status.HTTP_200_OK
assert is_response_paginated(response.data)
results = response.data['results']
# Check user ids
result_ids = [obj['id'] for obj in results]
expected_user_ids = [obj.user.id for obj in enrollments]
assert set(result_ids) == set(expected_user_ids)
def test_list_method_all(self, monkeypatch, enrollment_test_data):
"""Partial test coverage to check we get all site users
Checks returned user ids against all user ids for the site
Checks top level keys
Does NOT check values in the `enrollments` key. This should be done as
follow up work
"""
site = enrollment_test_data['site']
users = enrollment_test_data['users']
caller = self.make_caller(site, users)
other_site = SiteFactory()
assert site.domain != other_site.domain
response = self.make_request(request_path=self.base_request_path,
monkeypatch=monkeypatch,
site=site,
caller=caller,
action='list')
assert response.status_code == status.HTTP_200_OK
assert is_response_paginated(response.data)
results = response.data['results']
# Check user ids
result_ids = [obj['id'] for obj in results]
user_ids = get_user_ids_for_site(site=site)
assert set(result_ids) == set(user_ids)
# Spot check the first record
top_keys = [
'id', 'username', 'email', 'fullname', 'is_active', 'date_joined',
'enrollments'
]
assert set(results[0].keys()) == set(top_keys)
def test_bulk_calculate_course_progress_data_happy_path(db, monkeypatch):
"""Tests 'bulk_calculate_course_progress_data' function
The function under test iterates over a set of course enrollment records,
So we create a couple of records to iterate over and mock the collect
function
"""
course_overview = CourseOverviewFactory()
course_enrollments = [
CourseEnrollmentFactory(course_id=course_overview.id) for i in range(2)
]
mapping = {
ce.course_id:
LearnerCourseGradeMetricsFactory(course_id=str(ce.course_id),
user=ce.user,
sections_worked=1,
sections_possible=2)
for ce in course_enrollments
}
def mock_metrics(course_enrollment, **_kwargs):
return mapping[course_enrollment.course_id]
monkeypatch.setattr(
'figures.pipeline.enrollment_metrics.get_site_for_course',
lambda val: SiteFactory())
monkeypatch.setattr(
'figures.pipeline.enrollment_metrics.collect_metrics_for_enrollment',
mock_metrics)
data = bulk_calculate_course_progress_data(course_overview.id)
assert data['average_progress'] == 0.5
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 test_site_iterator():
sites = [SiteFactory() for i in range(5)]
collected_ids = []
for site_id in figures.sites.site_id_iterator(sites):
collected_ids.append(site_id)
assert set(collected_ids) == set([site.id for site in sites])
def test_populate_daily_metrics_for_site_basic(transactional_db,
monkeypatch,
date_for,
extra_params):
site = SiteFactory()
course_ids = [fake_course_key(i) for i in range(2)]
collected_course_ids = []
def fake_populate_single_cdm(course_id, **_kwargs):
collected_course_ids.append(course_id)
def fake_populate_single_sdm(site_id, **_kwargs):
assert site_id == site.id
def fake_update_enrollment_data_for_course(course_id):
assert extra_params['ed_next']
monkeypatch.setattr('figures.tasks.site_course_ids', lambda site: course_ids)
monkeypatch.setattr('figures.tasks.populate_single_cdm',
fake_populate_single_cdm)
monkeypatch.setattr('figures.tasks.populate_single_sdm',
fake_populate_single_sdm)
monkeypatch.setattr('figures.tasks.update_enrollment_data_for_course',
fake_update_enrollment_data_for_course)
populate_daily_metrics_for_site(site_id=site.id, date_for=date_for, **extra_params)
assert set(collected_course_ids) == set(course_ids)
def test_completed_method(self, monkeypatch, enrollment_test_data):
site = enrollment_test_data['site']
users = enrollment_test_data['users']
caller = self.make_caller(site, users)
other_site = SiteFactory()
assert site.domain != other_site.domain
# Create an LCGM record for the other site
LearnerCourseGradeMetricsFactory(site=other_site,
sections_worked=1,
sections_possible=1)
# Create an LCGM record for our site that is not completed
LearnerCourseGradeMetricsFactory(site=site,
sections_worked=1,
sections_possible=5)
completed_lcgm = [LearnerCourseGradeMetricsFactory(site=site,
sections_worked=5,
sections_possible=5)
for i in range(3)]
request_path = self.base_request_path + '/completed/'
response = self.make_request(request_path=request_path,
monkeypatch=monkeypatch,
site=site,
caller=caller,
action='completed')
assert response.status_code == status.HTTP_200_OK
assert is_response_paginated(response.data)
results = response.data['results']
# Check keys
result_ids = [obj['id'] for obj in results]
assert set(result_ids) == set([obj.id for obj in completed_lcgm])
# Spot check the first record
obj = LearnerCourseGradeMetrics.objects.get(id=results[0]['id'])
self.check_serialized_data(results[0], obj)
def test_populate_single_cdm(transactional_db, monkeypatch):
"""Test figures.tasks.populate_single_cdm nominal case
This tests the normal execution to popluate a single CourseDailyMetrics
record
"""
assert CourseDailyMetrics.objects.count() == 0
date_for = '2019-01-02'
course_id = "course-v1:certs-appsembler+001+2019"
created = False
def mock_cdm_load(self, date_for, **kwargs):
return (
CourseDailyMetricsFactory(date_for=date_for),
created,
)
monkeypatch.setattr('figures.sites.get_site_for_course',
lambda val: SiteFactory())
monkeypatch.setattr(
'figures.pipeline.course_daily_metrics.CourseDailyMetricsLoader.load',
mock_cdm_load)
populate_single_cdm(course_id, date_for)
assert CourseDailyMetrics.objects.count() == 1
assert as_date(
CourseDailyMetrics.objects.first().date_for) == as_date(date_for)
def test_list_method_filter_method_user_ids(self, monkeypatch, enrollment_test_data):
site = enrollment_test_data['site']
users = enrollment_test_data['users']
caller = self.make_caller(site, users)
other_site = SiteFactory()
assert site.domain != other_site.domain
check_user = users[0]
LearnerCourseGradeMetricsFactory(site=other_site)
LearnerCourseGradeMetricsFactory(site=site)
# Make sure we show only for our site for the selected user
LearnerCourseGradeMetricsFactory(site=other_site, user=check_user)
user_lcgm = [LearnerCourseGradeMetricsFactory(
site=site, user=check_user) for i in range(3)]
request_path = self.base_request_path + '?user_ids=' + str(check_user.id)
response = self.make_request(request_path=request_path,
monkeypatch=monkeypatch,
site=site,
caller=caller,
action='list')
assert response.status_code == status.HTTP_200_OK
assert is_response_paginated(response.data)
results = response.data['results']
# Check keys
result_ids = [obj['id'] for obj in results]
assert set(result_ids) == set([obj.id for obj in user_lcgm])
# Spot check the first record
obj = LearnerCourseGradeMetrics.objects.get(id=results[0]['id'])
self.check_serialized_data(results[0], obj)
def test_populate_daily_metrics_enrollment_data_error(transactional_db,
monkeypatch, caplog):
# Needs to be 'today' so that enrollment data update gets called
date_for = date.today()
site = SiteFactory()
def fake_populate_daily_metrics_for_site(**_kwargs):
pass
def fake_update_enrollment_data_fails(**kwargs):
# TODO: test with different exceptions
# At least one with and without `message_dict`
raise FakeException('Hey!')
monkeypatch.setattr('figures.tasks.populate_daily_metrics_for_site',
fake_populate_daily_metrics_for_site)
monkeypatch.setattr('figures.tasks.update_enrollment_data',
fake_update_enrollment_data_fails)
populate_daily_metrics(date_for=date_for)
last_log = caplog.records[-1]
expected_msg = ('{prefix}:FAIL figures.tasks update_enrollment_data '
' unhandled exception. site[{site_id}]:{domain}').format(
prefix=FPD_LOG_PREFIX,
site_id=site.id,
domain=site.domain)
assert last_log.message == expected_msg
def test_populate_daily_metrics_for_site_error_on_cdm(transactional_db,
monkeypatch, caplog):
date_for = date.today()
site = SiteFactory()
fake_course_ids = ['fake-course-id-1']
def fake_pop_single_cdm_fails(**kwargs):
# TODO: test with different exceptions
# At least one with and without `message_dict`
raise FakeException('Hey!')
monkeypatch.setattr('figures.tasks.site_course_ids',
lambda site: fake_course_ids)
monkeypatch.setattr('figures.tasks.populate_single_cdm',
fake_pop_single_cdm_fails)
populate_daily_metrics_for_site(site_id=site.id, date_for=date_for)
last_log = caplog.records[-1]
expected_msg = (
'{prefix}:SITE:COURSE:FAIL:populate_daily_metrics_for_site. '
'site_id:{site_id}, date_for:{date_for}. '
'course_id:{course_id} exception:{exception}').format(
prefix=FPD_LOG_PREFIX,
site_id=site.id,
date_for=date_for,
course_id=fake_course_ids[0],
exception='Hey!')
assert last_log.message == expected_msg
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, settings):
settings.FEATURES['FIGURES_IS_MULTISITE'] = True
is_multisite = figures.helpers.is_multisite()
assert is_multisite
self.site = SiteFactory(domain='foo.test')
self.organization = OrganizationFactory(sites=[self.site])
assert Site.objects.count() == 2
self.features = {'FIGURES_IS_MULTISITE': True}
def test_bulk_calculate_course_progress_no_enrollments(db, monkeypatch):
"""This tests when there is a new course with no enrollments
"""
monkeypatch.setattr(
'figures.pipeline.enrollment_metrics.get_site_for_course',
lambda val: SiteFactory())
course_overview = CourseOverviewFactory()
data = bulk_calculate_course_progress_data(course_overview.id)
assert data['average_progress'] == 0.0
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_get_sites_custom_backend(settings):
_orange_site = SiteFactory(name='orange site')
blue_site_1 = SiteFactory(name='blue site 1')
blue_site_2 = SiteFactory(name='blue site 2')
blue_sites = Site.objects.filter(name__startswith='blue site')
settings.ENV_TOKENS = {
'FIGURES': {
'SITES_BACKEND': 'organizations:get_blue_sites'
}
}
with mock.patch('organizations.get_blue_sites',
create=True,
return_value=blue_sites):
all_sites = figures.sites.get_sites()
assert list(all_sites) == [blue_site_1,
blue_site_2], 'Should return just blue sites.'
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'
