def _create_category(category_type='Category',
parent_category_id=None):
category = DegreeProgressCategory.create(
category_type=category_type,
name=
f'{category_type} for {sid} ({datetime.now().timestamp()})',
parent_category_id=parent_category_id,
position=1,
template_id=degree_check_id,
)
return category
def test_illegal_assign(self, client, fake_auth):
"""A course cannot be assigned to a category with a subcategory."""
advisor = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(advisor.uid)
sid = '11667051'
# Set up
degree_check = DegreeProgressTemplate.create(
advisor_dept_codes=['COENG'],
created_by=advisor.id,
degree_name=f'Degree for {sid}',
student_sid=sid,
)
category = DegreeProgressCategory.create(
category_type='Category',
name=f'Category for {sid}',
position=1,
template_id=degree_check.id,
)
# Subcategory
subcategory = DegreeProgressCategory.create(
category_type='Subcategory',
name=f'Subcategory for {sid}',
parent_category_id=category.id,
position=category.position,
template_id=degree_check.id,
)
std_commit(allow_test_environment=True)
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
course_id = api_json['courses']['unassigned'][-1]['id']
# Expect failure
_api_assign_course(category_id=category.id,
client=client,
course_id=course_id,
expected_status_code=400)
# Expect success
_api_assign_course(category_id=subcategory.id,
client=client,
course_id=course_id)
def _create_category(
category_type,
course_units_lower,
course_units_upper,
description,
name,
parent_category_id,
position,
template_id,
unit_requirement_ids,
):
campus_requirements = []
if category_type == 'Campus Requirements':
category_type = 'Category'
name = 'Campus Requirements'
campus_requirements = [
'Entry Level Writing', 'American History', 'American Institutions',
'American Cultures'
]
category = DegreeProgressCategory.create(
category_type=category_type,
course_units_lower=course_units_lower,
course_units_upper=course_units_upper,
description=description,
name=name,
parent_category_id=parent_category_id,
position=position,
template_id=template_id,
unit_requirement_ids=unit_requirement_ids,
)
for name in campus_requirements:
DegreeProgressCategory.create(
category_type='Campus Requirement, Unsatisfied',
name=name,
parent_category_id=category.id,
position=position,
template_id=template_id,
)
return category
def test_recommend_category(self, client, fake_auth, mock_template):
"""Authorized user can edit a category."""
user = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(user.uid)
category = DegreeProgressCategory.create(
category_type='Category',
name='Recommend me to your friends.',
position=1,
template_id=mock_template.id,
)
category_id = category.id
note = 'Four out of five dentists surveyed recommend sugarless gum for their patients who chew gum.'
self._api_recommend_category(
category_id=category_id,
client=client,
grade='B',
is_recommended=True,
note=note,
units_lower=3,
units_upper=4,
)
# Verify the update
api_json = _api_get_template(client=client,
template_id=mock_template.id)
category = api_json['categories'][0]
assert category['id'] == category_id
assert category['grade'] == 'B'
assert category['isRecommended'] is True
assert category['note'] == note
assert category['unitsLower'] == 3
assert category['unitsUpper'] == 4
# Set to False
self._api_recommend_category(
category_id=category_id,
client=client,
is_recommended=False,
note='',
)
api_json = _api_get_template(client=client,
template_id=mock_template.id)
category = api_json['categories'][0]
assert category['id'] == category_id
assert category['grade'] is None
assert category['isRecommended'] is False
assert category['note'] is None
assert category['unitsLower'] is None
assert category['unitsUpper'] is None
def test_assign_and_unassign_course(self, client, fake_auth):
"""User can assign and unassign a course."""
advisor = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(advisor.uid)
sid = '11667051'
# Set up
degree_check = DegreeProgressTemplate.create(
advisor_dept_codes=['COENG'],
created_by=advisor.id,
degree_name=f'Degree check for {sid}',
student_sid=sid,
)
original_updated_at = degree_check.updated_at
category = DegreeProgressCategory.create(
category_type='Category',
name=f'Category for {sid}',
position=1,
template_id=degree_check.id,
)
std_commit(allow_test_environment=True)
# Assign
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
course_id = api_json['courses']['unassigned'][-1]['id']
course = _api_assign_course(category_id=category.id,
client=client,
course_id=course_id)
# Verify assignment
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assert course['categoryId'] == category.id
assert course_id in [c['id'] for c in api_json['courses']['assigned']]
assert course_id not in [
c['id'] for c in api_json['courses']['unassigned']
]
# Unassign
_api_assign_course(category_id=None,
client=client,
course_id=course_id)
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assert course_id not in [
c['id'] for c in api_json['courses']['assigned']
]
assert course_id in [
c['id'] for c in api_json['courses']['unassigned']
]
# Verify update of updated_at
assert DegreeProgressTemplate.find_by_id(
degree_check.id).updated_at != original_updated_at
def _create_category(category_, parent_id):
unit_requirement_ids = []
for u in category_['unitRequirements']:
source_id_ = u['id']
cross_reference = unit_requirements_by_source_id[source_id_]
unit_requirement_ids.append(cross_reference.id)
return DegreeProgressCategory.create(
category_type=category_['categoryType'],
name=category_['name'],
position=category_['position'],
template_id=clone.id,
course_units_lower=category_['unitsLower'],
course_units_upper=category_['unitsUpper'],
description=category_['description'],
parent_category_id=parent_id,
unit_requirement_ids=unit_requirement_ids,
)
def test_unassigned_courses(self, client, fake_auth):
"""Authorized user can un-assign a course."""
advisor = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(advisor.uid)
# Set up
sid = '11667051'
degree_check = DegreeProgressTemplate.create(
advisor_dept_codes=['COENG'],
created_by=advisor.id,
degree_name=f'Degree check for {sid}',
student_sid=sid,
)
category = DegreeProgressCategory.create(
category_type='Category',
name=f'Category for {sid}',
position=1,
template_id=degree_check.id,
)
std_commit(allow_test_environment=True)
# Fetch
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assigned_courses = api_json['courses']['assigned']
unassigned_courses = api_json['courses']['unassigned']
assert len(unassigned_courses)
assigned_course_count = len(assigned_courses)
unassigned_course_count = len(unassigned_courses)
# Assign
unassigned_course = unassigned_courses[-1]
_api_assign_course(client=client,
category_id=category.id,
course_id=unassigned_course['id'])
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
# Verify
assigned_courses = api_json['courses']['assigned']
assert len(assigned_courses) == assigned_course_count + 1
assert next((c for c in unassigned_courses
if c['sectionId'] == unassigned_course['sectionId']),
None)
unassigned_courses = api_json['courses']['unassigned']
assert len(unassigned_courses) == unassigned_course_count - 1
assert next((c for c in unassigned_courses
if c['sectionId'] == unassigned_course['sectionId']),
None) is None
def copy_course():
params = request.get_json()
category_id = to_int_or_none(get_param(params, 'categoryId'))
category = category_id and DegreeProgressCategory.find_by_id(category_id)
if not category:
raise ResourceNotFoundError('Category not found.')
course_id = to_int_or_none(get_param(params, 'courseId'))
course = DegreeProgressCourse.find_by_id(course_id)
if not course:
raise ResourceNotFoundError('Course not found.')
sid = course.sid
section_id = course.section_id
term_id = course.term_id
degree_check_id = category.template_id
courses = DegreeProgressCourse.get_courses(
degree_check_id=degree_check_id,
manually_created_at=course.manually_created_at,
manually_created_by=course.manually_created_by,
section_id=section_id,
sid=sid,
term_id=term_id,
)
if not len(courses):
raise ResourceNotFoundError('Course not found.')
elif len(courses) == 1 and not courses[0].category_id:
raise BadRequestError(
f'Course {courses[0].id} is unassigned. Use the /assign API instead.'
)
else:
if not _can_accept_course_requirements(category):
raise BadRequestError(
f'A \'Course Requirement\' cannot be added to a {category.category_type}.'
)
# Verify that course is not already in the requested category/subcategory.
for c in DegreeProgressCourse.find_by_category_id(category.id):
if c.section_id == section_id and c.sid == sid and c.term_id:
raise BadRequestError(
f'Course already belongs to category {category.name}.')
for child in DegreeProgressCategory.find_by_parent_category_id(
category_id):
if child.id == category_id:
raise BadRequestError(
f'Course already belongs to category {category.name}.')
# Create a new course instance and a new 'Course Requirement'.
course = courses[0]
course = DegreeProgressCourse.create(
accent_color=course.accent_color,
degree_check_id=degree_check_id,
display_name=course.display_name,
grade=course.grade,
manually_created_at=course.manually_created_at,
manually_created_by=course.manually_created_by,
section_id=section_id,
sid=sid,
term_id=term_id,
unit_requirement_ids=[
u.unit_requirement_id for u in course.unit_requirements
],
units=course.units,
)
course_requirement = DegreeProgressCategory.create(
category_type='Placeholder: Course Copy',
name=course.display_name,
position=category.position,
template_id=degree_check_id,
course_units_lower=course.units,
course_units_upper=course.units,
parent_category_id=category.id,
unit_requirement_ids=[
u.unit_requirement_id for u in category.unit_requirements
],
)
DegreeProgressCourse.assign(category_id=course_requirement.id,
course_id=course.id)
return tolerant_jsonify(
DegreeProgressCourse.find_by_id(course.id).to_api_json())
def test_assign_and_unassign_course(self, app, client, fake_auth):
"""User can assign and unassign a course."""
advisor = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(advisor.uid)
sid = '11667051'
# Set up
degree_check = DegreeProgressTemplate.create(
advisor_dept_codes=['COENG'],
created_by=advisor.id,
degree_name=f'Degree check for {sid}',
student_sid=sid,
)
original_updated_at = degree_check.updated_at
category = DegreeProgressCategory.create(
category_type='Category',
name=f'Category for {sid}',
position=1,
template_id=degree_check.id,
)
std_commit(allow_test_environment=True)
# Assign
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
course_id = api_json['courses']['unassigned'][-1]['id']
course = _api_assign_course(category_id=category.id,
client=client,
course_id=course_id)
original_grade = course['grade']
assert original_grade == 'P'
# Verify assignment
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assert course['categoryId'] == category.id
assert course_id in [c['id'] for c in api_json['courses']['assigned']]
assert course_id not in [
c['id'] for c in api_json['courses']['unassigned']
]
# Modify grade in data lake and verify that assigned course receives the update
modified_grade = 'C+'
_change_grade_in_data_loch(
app=app,
grade=modified_grade,
section_id=course['sectionId'],
sid=sid,
term_id=course['termId'],
)
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assigned_course = api_json['courses']['assigned'][0]
assert assigned_course['id'] == course_id
assert assigned_course['grade'] == modified_grade
_change_grade_in_data_loch(
app=app,
grade=original_grade,
section_id=course['sectionId'],
sid=sid,
term_id=course['termId'],
)
# Unassign
_api_assign_course(category_id=None,
client=client,
course_id=course_id)
api_json = _api_get_degree(client, degree_check_id=degree_check.id)
assert course_id not in [
c['id'] for c in api_json['courses']['assigned']
]
unassigned_course = api_json['courses']['unassigned'][-1]
assert unassigned_course['id'] == course_id
assert unassigned_course['grade'] == original_grade
# Verify update of updated_at
assert DegreeProgressTemplate.find_by_id(
degree_check.id).updated_at != original_updated_at