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'