def test_count_courses_mixed_fa(self):
        """
        Test count_courses_passed with mixed course-exam configuration
        """
        mmtrack = MMTrack(
            user=self.user,
            program=self.program_financial_aid,
            edx_user_data=self.cached_edx_user_data
        )
        # this is course with exam run and the user has CombinedFinalGrade for it
        course_with_exam_1 = CourseFactory.create(program=self.program_financial_aid)
        ExamRunFactory.create(course=course_with_exam_1, date_grades_available=now_in_utc()-timedelta(weeks=1))
        CombinedFinalGrade.objects.create(user=self.user, course=course_with_exam_1, grade=0.7)
        # create course with exam run the user did not pass
        ExamRunFactory.create(
            course__program=self.program_financial_aid,
            date_grades_available=now_in_utc() - timedelta(weeks=1)
        )
        # another course with no exam
        FinalGradeFactory.create(
            user=self.user,
            course_run=self.crun_fa,
            passed=True
        )

        assert mmtrack.count_courses_passed() == 2

    def setUpTestData(cls):
        cls.user = SocialUserFactory.create()

        cls.run_fa = CourseRunFactory.create(
            freeze_grade_date=now_in_utc()-timedelta(days=1),
            course__program__financial_aid_availability=True,
        )
        cls.run_fa_with_cert = CourseRunFactory.create(
            freeze_grade_date=None,
            course__program=cls.run_fa.course.program,
        )

        cls.run_no_fa = CourseRunFactory.create(
            freeze_grade_date=now_in_utc()+timedelta(days=1),
            course__program__financial_aid_availability=False,
        )
        cls.run_no_fa_with_cert = CourseRunFactory.create(
            course__program=cls.run_no_fa.course.program,
        )

        all_course_runs = (cls.run_fa, cls.run_fa_with_cert, cls.run_no_fa, cls.run_no_fa_with_cert, )

        for run in all_course_runs:
            if run.course.program.financial_aid_availability:
                FinancialAidFactory.create(
                    user=cls.user,
                    tier_program=TierProgramFactory.create(
                        program=run.course.program, income_threshold=0, current=True
                    ),
                    status=FinancialAidStatus.RESET,
                )

        cls.enrollments = {
            course_run.edx_course_key: CachedEnrollmentFactory.create(
                user=cls.user, course_run=course_run) for course_run in all_course_runs
        }

        cls.current_grades = {
            course_run.edx_course_key: CachedCurrentGradeFactory.create(
                user=cls.user, course_run=course_run) for course_run in all_course_runs
        }

        cls.certificates = {
            course_run.edx_course_key: CachedCertificateFactory.create(
                user=cls.user, course_run=course_run) for course_run in (cls.run_fa_with_cert, cls.run_no_fa_with_cert)
        }

        cls.user_edx_data = CachedEdxUserData(cls.user)

 def test_props(self, program_data):
     """
     Fixture that provides test properties for FinancialAidDetailView test cases
     """
     user = create_enrolled_profile(program_data.program).user
     pending_fa = FinancialAidFactory.create(
         user=user,
         tier_program=program_data.tier_programs["25k"],
         status=FinancialAidStatus.PENDING_DOCS
     )
     docs_sent_url = reverse(
         "financial_aid",
         kwargs={"financial_aid_id": pending_fa.id}
     )
     docs_sent_date = now_in_utc().date()
     docs_sent_request_params = dict(
         content_type="application/json",
         data=json.dumps({
             "date_documents_sent": docs_sent_date.strftime("%Y-%m-%d")
         })
     )
     return SimpleNamespace(
         user=user,
         pending_fa=pending_fa,
         docs_sent_url=docs_sent_url,
         docs_sent_request_params=docs_sent_request_params,
         docs_sent_date=docs_sent_date,
     )

def calculate_users_to_refresh_in_bulk():
    """
    Calculate the set of user ids which would be updated when running a bulk update. This uses a 6 hour delta
    because this is a bulk operation. For individual updates see CachedEdxDataApi.is_cache_fresh.

    Returns:
        list of int: A list of user ids which need to be updated
    """
    refresh_time_limit = now_in_utc() - datetime.timedelta(hours=6)

    all_users = User.objects.filter(is_active=True, profile__fake_user=False).exclude(social_auth=None)

    con = get_redis_connection("redis")
    user_ids_invalid_credentials = con.smembers(CACHE_KEY_FAILED_USERS_NOT_TO_UPDATE)

    # If one of these fields is null in the database the gte expression will be false, so we will refresh those users
    users_not_expired = all_users.filter(
        usercacherefreshtime__enrollment__gte=refresh_time_limit,
        usercacherefreshtime__certificate__gte=refresh_time_limit,
        usercacherefreshtime__current_grade__gte=refresh_time_limit
    )

    return list(
        all_users
        .exclude(id__in=users_not_expired.values_list("id", flat=True))
        .exclude(id__in=user_ids_invalid_credentials)
        .values_list("id", flat=True)
    )

    def get(self, request, *args, **kargs):  # pylint: disable=unused-argument, no-self-use
        """
        Request for exam SSO parameters
        """
        profile = request.user.profile
        student_id = profile.student_id

        if not ExamProfile.objects.filter(
                profile=profile,
                status=ExamProfile.PROFILE_SUCCESS,
        ).exists():
            # UI should in theory not send a user here in this state,
            # but it's not impossible so let's handle it politely
            return Response(data={
                'error': 'You are not ready to schedule an exam at this time',
            }, status=status.HTTP_403_FORBIDDEN)

        timestamp = int(now_in_utc().timestamp())
        session_timeout = request.session.get_expiry_age()

        try:
            digest = sso_digest(student_id, timestamp, session_timeout)
        except ImproperlyConfigured:
            return Response(status=500)

        return Response(data={
            'sso_digest': digest,
            'timestamp': timestamp,
            'session_timeout': session_timeout,
            'sso_redirect_url': request.build_absolute_uri('/'),
        })

def create_user_for_login(is_staff=True, username=None):
    """Create a test user that can log into the app"""
    later = now_in_utc() + timedelta(weeks=5000)
    with mute_signals(post_save):
        user = SocialProfileFactory.create(
            validated=True,
            user__is_staff=is_staff,
            image=None,  # make these None so the default image is used
            image_small=None,
            image_medium=None,
            **({'user__username': username} if username is not None else {}),
            user__social_auth__extra_data={
                'access_token': 'fake',
                'refresh_token': 'fake',
                'updated_at': later.timestamp(),
                'expires_in': 3600,
            }
        ).user

    UserCacheRefreshTime.objects.create(
        user=user,
        enrollment=later,
        certificate=later,
        current_grade=later,
    )
    user.set_password(DEFAULT_PASSWORD)
    user.save()
    return user

 def test_is_cache_fresh(self):
     """Test for is_cache_fresh"""
     with self.assertRaises(ValueError):
         CachedEdxDataApi.is_cache_fresh(self.user, 'footype')
     # if there is no entry in the table, the cache is not fresh
     assert UserCacheRefreshTime.objects.filter(user=self.user).exists() is False
     for cache_type in CachedEdxDataApi.SUPPORTED_CACHES:
         assert CachedEdxDataApi.is_cache_fresh(self.user, cache_type) is False
     now = now_in_utc()
     user_cache = UserCacheRefreshTimeFactory.create(
         user=self.user,
         enrollment=now,
         certificate=now,
         current_grade=now,
     )
     for cache_type in CachedEdxDataApi.SUPPORTED_CACHES:
         assert CachedEdxDataApi.is_cache_fresh(self.user, cache_type) is True
     # moving back the timestamp of one day, makes the cache not fresh again
     yesterday = now - timedelta(days=1)
     user_cache.enrollment = yesterday
     user_cache.certificate = yesterday
     user_cache.current_grade = yesterday
     user_cache.save()
     for cache_type in CachedEdxDataApi.SUPPORTED_CACHES:
         assert CachedEdxDataApi.is_cache_fresh(self.user, cache_type) is False

    def test_sso_get_with_exam_profile_success(self):
        """
        Test issuing a GET request when user has an ExamProfile in PROFILE_SUCCESS status
        """
        ExamProfile.objects.create(
            profile=self.user.profile,
            status=ExamProfile.PROFILE_SUCCESS,
        )

        with patch('exams.views.sso_digest', return_value='test value'):
            response = self.client.get(reverse("pearson_sso_api"))
            result = response.json()
            assert response.status_code == status.HTTP_200_OK

            timestamp = result['timestamp']
            assert isinstance(timestamp, int)

            now = int(now_in_utc().timestamp())
            assert now - timestamp < 5

            assert result['sso_digest'] == 'test value'

            # best we can assert is that this is an integer
            assert isinstance(result['session_timeout'], int)

            assert result['sso_redirect_url'] == 'http://testserver/'

def from_weeks(weeks, now=None):
    """Helper function to get a date adjusted by a number of weeks"""
    if weeks is None:
        return None
    if now is None:
        now = now_in_utc()
    return now + timedelta(weeks=weeks)

    def save(self, **kwargs):
        """
        Override save method
        """
        try:
            income_usd = determine_income_usd(
                self.validated_data["original_income"],
                self.validated_data["original_currency"]
            )
        except NotSupportedException:
            raise ValidationError("Currency not supported")
        user = self.context["request"].user
        tier_program = determine_tier_program(self.validated_data["program"], income_usd)

        financial_aid = FinancialAid.objects.create(
            original_income=self.validated_data["original_income"],
            original_currency=self.validated_data["original_currency"],
            tier_program=tier_program,
            user=user,
            income_usd=income_usd,
            country_of_income=user.profile.country,
            date_exchange_rate=now_in_utc(),
            country_of_residence=user.profile.country,
        )

        if determine_auto_approval(financial_aid, tier_program) is True:
            financial_aid.status = FinancialAidStatus.AUTO_APPROVED
        else:
            financial_aid.status = FinancialAidStatus.PENDING_DOCS
        financial_aid.save_and_log(user)

        return financial_aid

 def test_no_frozen_runs(self):
     """
     The course has run with no grading status
     """
     now = now_in_utc()
     self.create_run(freeze_grade_date=now - timedelta(weeks=1))
     assert self.course.has_frozen_runs() is False

def batch_update_user_data():
    """
    Create sub tasks to update user data like enrollments,
    certificates and grades from edX platform.
    """
    expiration = now_in_utc() + timedelta(hours=5)
    lock = Lock(LOCK_ID, expiration)
    if not lock.acquire():
        # Lock should have expired by now
        log.error("Unable to acquire lock for batch_update_user_data")
        return

    users_to_refresh = calculate_users_to_refresh_in_bulk()

    jobs = release_batch_update_user_data_lock.s(token=lock.token.decode())
    try:
        if len(users_to_refresh) > 0:
            user_id_chunks = chunks(users_to_refresh)

            job = group(
                batch_update_user_data_subtasks.s(user_id_chunk, expiration.timestamp())
                for user_id_chunk in user_id_chunks
            )
            jobs = job | jobs
    finally:
        jobs.delay()

    def test_get_pearson_exam_status(self, profile_status, expected_status, make_exam_run,
                                     make_profile, make_auth, log_error_called, log_mock):
        """
        test get_pearson_exam_status
        """
        now = now_in_utc()
        exam_run = None
        if make_exam_run:
            exam_run = ExamRunFactory.create(
                course=self.course,
                date_first_eligible=now - timedelta(weeks=1),
                date_last_eligible=now + timedelta(weeks=1),
            )

        if make_profile:
            ExamProfileFactory.create(
                profile=self.user.profile,
                status=profile_status,
            )

        if make_auth:
            ExamAuthorizationFactory.create(
                user=self.user,
                status=ExamAuthorization.STATUS_SUCCESS,
                exam_run=exam_run,
            )

        mmtrack = MMTrack(
            user=self.user,
            program=self.program,
            edx_user_data=self.cached_edx_user_data
        )

        assert mmtrack.get_pearson_exam_status() == expected_status
        assert log_mock.error.called is log_error_called

    def handle_cdd(self, sftp_conn, remote_path, ratio):
        """Handle a CDD file"""
        now = now_in_utc()
        result_file = io.StringIO()
        writer = csv.DictWriter(result_file, [
            'ClientCandidateID',
            'Status',
            'Date',
            'Message',
        ], delimiter='\t')
        writer.writeheader()
        with sftp_conn.open(remote_path, mode='r') as cdd_file:
            for row in csv.DictReader(cdd_file, delimiter='\t'):
                cid = row['ClientCandidateID']
                error = random.random() > ratio
                status = 'Error' if error else 'Accepted'
                self.stdout.write('Marking profile {cid} as {status}'.format(
                    cid=cid,
                    status=status,
                ))
                writer.writerow({
                    'ClientCandidateID': cid,
                    'Status': 'Error' if error else 'Accepted',
                    'Date': now.strftime(PEARSON_DEFAULT_DATETIME_FORMAT),
                    'Message': 'Invalid Address' if error else '',
                })

        self.write_zip(
            sftp_conn,
            result_file.getvalue(),
            now.strftime('{}-%Y-%m-%d.dat'.format(PEARSON_FILE_TYPES.VCDC)),
            now
        )

 def can_freeze_grades(self):
     """
     Checks if the final grades can be frozen.
     """
     if self.freeze_grade_date is None:
         raise ImproperlyConfigured('Missing freeze_grade_date')
     return now_in_utc() > self.freeze_grade_date

 def is_upgradable(self):
     """
     Checks if the course can be upgraded
     A null value means that the upgrade window is always open
     """
     return (self.upgrade_deadline is None or
             (self.upgrade_deadline > now_in_utc()))

    def test_update_cache_last_access(self):
        """Test for update_cache_last_access"""
        with self.assertRaises(ValueError):
            CachedEdxDataApi.update_cache_last_access(self.user, 'footype')
        assert UserCacheRefreshTime.objects.filter(user=self.user).exists() is False

        CachedEdxDataApi.update_cache_last_access(self.user, CachedEdxDataApi.ENROLLMENT)
        cache_time = UserCacheRefreshTime.objects.get(user=self.user)
        assert cache_time.enrollment <= now_in_utc()
        assert cache_time.certificate is None
        assert cache_time.current_grade is None

        old_timestamp = now_in_utc() - timedelta(days=1)
        CachedEdxDataApi.update_cache_last_access(self.user, CachedEdxDataApi.ENROLLMENT, old_timestamp)
        cache_time.refresh_from_db()
        assert cache_time.enrollment == old_timestamp

    def test_get_best_proctored_exam_grade(self):
        """
        Test get_best_proctorate_exam_grade to return a passed exam with the highest score
        """
        mmtrack = MMTrack(
            user=self.user,
            program=self.program_financial_aid,
            edx_user_data=self.cached_edx_user_data
        )
        finaid_course = self.crun_fa.course
        last_week = now_in_utc() - timedelta(weeks=1)

        ProctoredExamGradeFactory.create(user=self.user, course=finaid_course, passed=False, percentage_grade=0.6)
        assert mmtrack.get_best_proctored_exam_grade(finaid_course) is None
        best_exam = ProctoredExamGradeFactory.create(
            user=self.user, course=finaid_course, passed=True, percentage_grade=0.9,
            exam_run__date_grades_available=last_week
        )
        assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam

        ProctoredExamGradeFactory.create(
            user=self.user, course=finaid_course, passed=True, percentage_grade=0.8,
            exam_run__date_grades_available=last_week
        )
        assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam

    def test_update_exam_authorization_cached_enrollment_when_no_exam_run(self):
        """
        Test no exam profile created when course has no ExamRun
        """
        self.exam_run.delete()
        course = CourseFactory.create(program=self.program)
        course_run = CourseRunFactory.create(
            end_date=now_in_utc() - timedelta(days=100),
            enrollment_end=now_in_utc() + timedelta(hours=1),
            course=course
        )
        create_order(self.profile.user, course_run)

        # exam profile before enrollment.
        assert ExamProfile.objects.filter(profile=self.profile).exists() is False
        CachedEnrollmentFactory.create(user=self.profile.user, course_run=course_run)
        assert ExamProfile.objects.filter(profile=self.profile).exists() is False

 def is_current(self):
     """Checks if the course is running now"""
     if not self.start_date:
         return False
     now = now_in_utc()
     if not self.end_date:
         return self.start_date <= now
     return self.start_date <= now <= self.end_date