def test_audit__double_history_and_studio():
student: Dict[str, Any] = {
'areas': [
AreaPointer(
code='140',
status=AreaStatus.Declared,
kind=AreaType.Major,
name='Studio Art',
degree='B.A.',
dept='ART',
gpa=None,
terms_since_declaration=None,
),
AreaPointer(
code='135',
status=AreaStatus.Declared,
kind=AreaType.Major,
name='Art History',
degree='B.A.',
dept='ART',
gpa=None,
terms_since_declaration=None,
),
],
'courses': [
course_from_str('DEPT 123'),
],
}
c = Constants(matriculation_year=2000)
area = AreaOfStudy.load(c=c,
student=Student.load(
dict(areas=student['areas'],
courses=student['courses'])),
specification={
'name': 'Art History Test',
'type': 'major',
'code': '140',
'degree': 'B.A.',
'result': {
'all': [{
'course': 'DEPT 123'
}],
}
})
messages = list(
audit(area=area,
student=Student.load(
dict(areas=student['areas'], courses=student['courses']))))
result = messages[-1].result
assert result.result.items[-1].result.items[-1].result.assertions[
0].expected == 18
def test_pruning_on_count_rule(caplog):
caplog.set_level(logging.DEBUG)
area = AreaOfStudy.load(specification={
"result": {
"any": [
{
"course": "DEPT 123"
},
{
"course": "DEPT 234"
},
{
"course": "DEPT 345"
},
],
},
},
c=c)
course_a = course_from_str("DEPT 123", clbid="0")
course_b = course_from_str("DEPT 234", clbid="1")
transcript = [course_a, course_b]
solutions = list(
area.solutions(student=Student.load(dict(courses=transcript)),
exceptions=[]))
assert [[
x.course for x in s.solution.items if isinstance(x, CourseResult)
] for s in solutions] == [['DEPT 123', 'DEPT 234']]
assert len(solutions) == 1
result = solutions[0].audit()
assert result.result.count == 1
assert result.is_ok() is True
assert result.is_waived() is False
assert result.claims()[0].course.clbid == course_a.clbid
def test_sum_credits_from_single_subject__multiple_solutions():
result = funcs.sum_credits_from_single_subject([
course_from_str("A 100", credits=Decimal('1')),
course_from_str("B 200", credits=Decimal('1')),
])
assert result.value == Decimal('1.0')
assert sorted(result.data) == [Decimal('1')]
assert len(result.courses) == 1
result_a = list(result.courses)[0]
result = funcs.sum_credits_from_single_subject([
course_from_str("B 200", credits=Decimal('1')),
course_from_str("A 100", credits=Decimal('1')),
])
assert len(result.courses) == 1
result_b = list(result.courses)[0]
# We're asserting that no matter how the input is sorted, when
# two subjects both have the most credits, the "higher" subject
# in the alphabet is chosen.
assert result_a.subject == result_b.subject == 'B'
def test_su_during_covid_different_clause() -> None:
ctx = RequirementContext()
clause = load_predicate({"grade": {"$gte": "B"}}, c=c, mode=mode, ctx=ctx)
assert isinstance(clause, Predicate)
course = course_from_str(
'CSCI 251',
grade_code='S',
grade_option=GradeOption.SU,
su_grade_code='C',
year=2019,
term='3',
)
assert apply_predicate__grade(course, clause) is False
def test_mc__none_2(caplog):
caplog.set_level(logging.DEBUG, logger='dp.context')
test_data = io.StringIO("""
result:
either:
- requirement: Root
- requirement: Alt
requirements:
Root:
result:
course: DEPT 123
Alt:
result:
course: DEPT 123
multicountable:
DEPT 123:
- [Root]
""")
area = AreaOfStudy.load(specification=yaml.load(stream=test_data,
Loader=yaml.SafeLoader),
c=c)
course = course_from_str('DEPT 123')
solutions = area.solutions(student=Student.load(dict(courses=[course])),
exceptions=[])
results = [s.audit() for s in solutions]
assert len(results) == 3
result_a, result_b, result_c = results
assert result_a.is_ok() is True
assert result_b.is_ok() is True
assert result_c.is_ok() is True
assert list(c.course.course() for c in result_c.claims()
if c.failed is False) == [course.course()]
assert result_c.result.items[0].result.claim_attempt.failed is False
assert result_c.result.items[1].result.claim_attempt.failed is True
def test_overlaps(caplog: Any) -> None:
# caplog.set_level(logging.DEBUG)
global c
area = AreaOfStudy.load(c=c, specification={
"result": {"all": [
{"requirement": "Core"},
{"requirement": "Electives"},
]},
"requirements": {
"Core": {
"result": {"all": [
{"course": "MUSIC 212"},
{"course": "MUSIC 214"},
]},
},
"Electives": {
"result": {
"from": "courses",
"where": {
"$and": [
{"subject": {"$eq": "MUSIC"}},
{"level": {"$eq": [300]}},
],
},
"all": [
{"assert": {"count(courses)": {"$gte": 2}}},
],
},
},
},
})
transcript = [course_from_str(c) for c in ["MUSIC 212", "MUSIC 214", "MUSIC 301", "MUSIC 302"]]
ctx = RequirementContext().with_transcript(transcript)
area.result.find_independent_children(items=area.result.items, ctx=ctx)
solutions = list(area.solutions(student=Student.load(dict(courses=transcript)), exceptions=[]))
assert len(solutions) == 1
result = solutions[0].audit()
assert result.is_ok() is True
def test_mc__only_query_references(caplog):
caplog.set_level(logging.DEBUG, logger='dp.context')
test_data = io.StringIO("""
result:
all:
- requirement: Root
- requirement: Alt
requirements:
Root:
result:
from: courses
assert: {count(courses): {$gte: 1}}
Alt:
result:
from: courses
assert: {count(courses): {$gte: 1}}
multicountable:
DEPT 123:
- [Root]
- [Alt]
""")
area = AreaOfStudy.load(specification=yaml.load(stream=test_data,
Loader=yaml.SafeLoader),
c=c)
course = course_from_str('DEPT 123')
solutions = area.solutions(student=Student.load(dict(courses=[course])),
exceptions=[])
results = [s.audit() for s in solutions]
assert len(results) == 1
result_a = results[0]
assert result_a.is_ok() is True
assert list(c.course.course() for c in result_a.claims()
if c.failed is False) == [course.course(),
course.course()]
def test_graded_during_covid() -> None:
ctx = RequirementContext()
clause = load_predicate({"grade": {
"$gte": "C",
"$during_covid": "C-"
}},
c=c,
mode=mode,
ctx=ctx)
assert isinstance(clause, Predicate)
course = course_from_str(
'CSCI 251',
grade_code='C',
grade_option=GradeOption.Grade,
year=2019,
term='3',
)
assert apply_predicate__grade(course, clause) is True
def test_claims__claimed(benchmark):
course = course_from_str('AMCON 101')
context = RequirementContext()
kwargs = {
'course':
course,
'allow_claimed':
False,
'path':
tuple([
"$", "%Common Requirements", ".count", "[2]",
"%Credits outside the major", ".query", ".assertions", "[0]",
".assert", '*AMCON 101'
]),
}
context.make_claim(**kwargs)
benchmark(do_claim_2, context=context, **kwargs)
def test_clauses_in(caplog):
caplog.set_level(logging.DEBUG)
c = Constants(matriculation_year=2000)
ctx = RequirementContext()
course = course_from_str(s="CSCI 296")
values = tuple([296, 298, 396, 398])
x = load_predicate({"number": {
"$in": values
}},
c=c,
ctx=ctx,
mode=DataType.Course)
expected_single = Predicate.from_args(key="number",
expected=values,
original=values,
operator=Operator.In)
assert x == expected_single
assert x.apply(course) is True
def test_clauses(caplog):
caplog.set_level(logging.DEBUG)
c = Constants(matriculation_year=2000)
ctx = RequirementContext()
x = load_predicate({"attributes": {
"$eq": "csci_elective"
}},
c=c,
ctx=ctx,
mode=DataType.Course)
expected_single = Predicate.from_args(key="attributes",
expected="csci_elective",
original="csci_elective",
operator=Operator.EqualTo)
assert x == expected_single
crs = course_from_str(s="CSCI 121", attributes=["csci_elective"])
assert x.apply(crs) is True
def trns():
return [
course_from_str('CSCI 251', grade_points=Decimal('3.0'), credits=Decimal('1.0')),
course_from_str('CSCI 275', grade_points=Decimal('2.0'), credits=Decimal('1.0')),
course_from_str('ART 101', grade_points=Decimal('1.0'), credits=Decimal('1.0')),
]
def test_pred_expr_has_course():
ctx = RequirementContext().with_transcript([course_from_str('AMCON 101')])
assert load_predicate_expression({
'has-course': 'AMCON 101'
}, ctx=ctx).result is True
def x_test_overlaps(caplog: Any) -> None:
# caplog.set_level(logging.DEBUG)
area = AreaOfStudy.load(c=c, specification={
"result": {"all": [
{"requirement": "Core"},
{"requirement": "Electives"},
{"requirement": "Lessons"},
]},
"requirements": {
"Core": {
"result": {"all": [
{"course": "MUSIC 212"},
{"course": "MUSIC 214"},
{"course": "MUSIC 237"},
{"course": "MUSIC 251"},
{"course": "MUSIC 261"},
{"course": "MUSIC 298"},
]},
},
"Electives": {
"result": {
"from": "courses",
"where": {
"$and": [
{"subject": {"$eq": "MUSIC"}},
{"level": {"$in": [200, 300]}},
],
},
"all": [
{"assert": {"count(courses)": {"$gte": 8}}},
{
"where": {"level": {"$eq": 300}},
"assert": {"count(courses)": {"$gte": 2}},
},
],
},
},
"Lessons": {
"result": {
"from": "courses",
"where": {"subject": {"$eq": "MUSPF"}},
"all": [
{"assert": {"count(terms)": {"$gte": 6}}},
{"assert": {"sum(credits)": {"$gte": 2.5}}},
{
"where": {"credits": {"$eq": 0.5}},
"assert": {"count(terms)": {"$gte": 4}},
},
],
},
},
},
})
transcript = [course_from_str(c) for c in [
"MUSIC 212", "MUSIC 214", "MUSIC 237", "MUSIC 251", "MUSIC 252", "MUSIC 298",
"MUSIC 222", "MUSIC 224", "MUSIC 247", "MUSIC 261", "MUSIC 262", "MUSIC 299", "MUSIC 301", "MUSIC 302",
"MUSPF 101", "MUSPF 102", "MUSPF 103", "MUSPF 104", "MUSPF 105", "MUSPF 106",
]]
solutions = list(area.solutions(student=Student.load(dict(courses=transcript)), exceptions=[]))
assert len(solutions) == 1
result = solutions[0].audit()
assert result.is_ok() is True
