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): # 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 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 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 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.default_site = Site.objects.get(id=1) self.organization = OrganizationFactory(sites=[self.site]) self.default_site_org = OrganizationFactory(sites=[self.default_site]) assert Site.objects.count() == 2 self.features = {'FIGURES_IS_MULTISITE': True}
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_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 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 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 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 map_users_to_org_site(caller, site, users): org = OrganizationFactory(sites=[site]) UserOrganizationMappingFactory(user=caller, organization=org, is_amc_admin=True) [UserOrganizationMappingFactory(user=user, organization=org) for user in users] # return created objects that the test will need return caller
def test_create_organiztion_with_site(self): """ Make sure that we cannot associate an organization with a site Another way to check is if organizations.models.Organization has the 'sites' field via `hasattr` """ with pytest.raises(TypeError): OrganizationFactory(sites=[self.site])
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_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 setup(self, db, settings): 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_org = OrganizationFactory(sites=[self.alpha_site]) self.alpha_site_daily_metrics = create_site_daily_metrics_data( site=self.alpha_site, start_date=self.data_start_date, end_date=self.data_end_date) self.bravo_site = SiteFactory(domain='bravo.site') self.bravo_org = OrganizationFactory(sites=[self.bravo_site]) self.bravo_site_daily_metrics = create_site_daily_metrics_data( site=self.bravo_site, start_date=self.data_start_date, end_date=self.data_end_date)
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.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 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 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, 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 get_user_model().objects.count() == 0 self.users = [UserFactory() for i in range(3)] for user in self.users: UserOrganizationMappingFactory(user=user, organization=self.organization) assert Site.objects.count() == 2 self.features = {'FIGURES_IS_MULTISITE': True}
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 test_multiple_user_orgs(self, monkeypatch, settings): def test_site(request): return self.site username = '******' request = APIRequestFactory().get('/') request.META['HTTP_HOST'] = self.site.domain request.user = get_user_model().objects.get(username=username) monkeypatch.setattr(django.contrib.sites.shortcuts, 'get_current_site', test_site) settings.FEATURES['FIGURES_IS_MULTISITE'] = True assert figures.helpers.is_multisite() org2 = OrganizationFactory(sites=[self.site]) UserOrganizationMappingFactory(user=request.user, organization=org2), with pytest.raises(figures.permissions.MultipleOrgsPerUserNotSupported): figures.permissions.IsSiteAdminUser().has_permission(request, None)
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 handle(self, *args, **options): if options['flush']: print "delete all data in app tables" RegistrationProfile.objects.all().delete() Shift.objects.all().delete() Task.objects.all().delete() Workplace.objects.all().delete() Facility.objects.all().delete() UserAccount.objects.all().delete() # delete geographic information Country.objects.all().delete() Region.objects.all().delete() Area.objects.all().delete() Place.objects.all().delete() User.objects.filter().exclude(is_superuser=True).delete() # create regional data places = list() for i in range(0, 10): places.append(PlaceFactory.create()) organizations = list() for i in range(0, 4): organizations.append(OrganizationFactory.create()) # create shifts for number of days for day in range(0, options['days'][0]): for i in range(2, 23): place = places[random.randint(0, len(places) - 1)] organization = organizations[random.randint( 0, len(organizations) - 1)] facility = FacilityFactory.create(description=LOREM, place=place, organization=organization) shift = ShiftFactory.create(starting_time=gen_date(hour=i - 1, day=day), ending_time=gen_date(hour=i, day=day), facility=facility) # assign random volunteer for each shift reg_user = ShiftHelperFactory.create(shift=shift) reg_user.save()
def handle(self, *args, **options): if options['flush']: print "delete all data in app tables" RegistrationProfile.objects.all().delete() Shift.objects.all().delete() Task.objects.all().delete() Workplace.objects.all().delete() Facility.objects.all().delete() UserAccount.objects.all().delete() # delete geographic information Country.objects.all().delete() Region.objects.all().delete() Area.objects.all().delete() Place.objects.all().delete() User.objects.filter().exclude(is_superuser=True).delete() # create regional data places = list() for i in range(0, 10): places.append(PlaceFactory.create()) organizations = list() for i in range(0, 4): organizations.append(OrganizationFactory.create()) # create shifts for number of days for day in range(0, options['days'][0]): for i in range(2, 23): place = places[random.randint(0, len(places) - 1)] organization = organizations[random.randint(0, len(organizations) - 1)] facility = FacilityFactory.create( description=LOREM, place=place, organization=organization ) shift = ShiftFactory.create( starting_time=gen_date(hour=i - 1, day=day), ending_time=gen_date(hour=i, day=day), facility=facility ) # assign random volunteer for each shift reg_user = ShiftHelperFactory.create(shift=shift) reg_user.save()
def setup(self, db): self.site = SiteFactory() self.organization = OrganizationFactory(sites=[self.site]) self.callers = [ UserFactory(username='******'), UserFactory(username='******'), UserFactory(username='******'), ] self.user_organization_mappings = [ UserOrganizationMappingFactory(user=self.callers[0], organization=self.organization), UserOrganizationMappingFactory(user=self.callers[1], organization=self.organization, is_amc_admin=True) ] self.callers += create_test_users() self.features = {'FIGURES_IS_MULTISITE': True}
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_with_course_id_for_other_site(self): """ This tests if the course can't be found in the organization This test is incomplete """ with mock.patch('figures.helpers.settings.FEATURES', {'FIGURES_IS_MULTISITE': True}): assert figures.helpers.is_multisite() # Stand up other site. Candidate for a fixture other_site = SiteFactory(domain='other.site') other_org = OrganizationFactory(sites=[other_site]) course = CourseOverviewFactory(org=other_org.short_name) request = APIRequestFactory().get(self.request_path) force_authenticate(request, user=self.staff_user) view = self.view_class.as_view({'get': 'retrieve'}) response = view(request, pk=str(course.id)) assert response.status_code == 403