def test_dump_local_course(model):
path = fixture_path / 'minimal-courses'
model.add_course(
models.Course.load_local(
parent=model,
path=path,
repo_info=get_local_repo_info(path),
slug='courses/minimal',
))
assert_yaml_dump(models.dump(model), 'minimal-root.yml')
course = model.courses['courses/minimal']
assert_yaml_dump(models.dump(course), 'minimal-course.yml')
def test_course_with_no_default_time(model):
add_test_course(model, 'courses/without-default-time', {
'title': 'Test course without scheduled times',
'sessions': SESSIONS,
})
course = model.courses['courses/without-default-time']
assert course.default_time is None
session = course.sessions['normal-session']
assert session.date == datetime.date(2000, 1, 1)
assert session.time is None
session = course.sessions['afterparty']
assert session.date == datetime.date(2000, 1, 1)
assert session.time == {
'start': datetime.datetime(2000, 1, 1, 22, tzinfo=TZINFO),
'end': datetime.datetime(2000, 1, 1, 23, tzinfo=TZINFO),
}
session = course.sessions['self-study']
assert session.date == None
assert session.time == None
session = course.sessions['morning-meditation']
assert session.date == None
assert session.time == None
assert_yaml_dump(models.dump(course), 'session-times/without-default-time')
def test_valid_fork(arca_model, content_repo):
"""Valid data can be loaded from a Git repository"""
course = models.Course.load_remote(
'courses/normal-course',
parent=arca_model,
link_info={'repo': content_repo.as_uri()},
)
arca_model.add_course(course)
assert_yaml_dump(models.dump(course), 'normal-course.yaml')
def test_complex_course(model):
"""Valid complex json that could come from a fork is loaded correctly"""
course = load_course_from_fixture(model, 'course-data/complex-course.yml')
assert_yaml_dump(models.dump(course), 'complex-course.yml')
# Make sure HTML is sanitized
assert course.long_description == 'A <em>fun course!</em>'
assert course.sessions['full'].description == 'A <em>full session!</em>'
def test_fork_link(arca_model, content_repo, tmp_path, slug):
"""Test data is loaded via link.yml pointing to a repository"""
link_info = {'repo': content_repo.as_uri(), 'branch': 'master'}
make_data_with_fork_link(
tmp_path,
LINK_INFO[slug]["path"],
json.dumps(link_info),
)
arca_model.load_local_courses(tmp_path / 'data')
course = arca_model.courses[slug]
assert_yaml_dump(models.dump(course), LINK_INFO[slug]['expected_file'])
def test_empty_course_from_renderer(model):
"""Valid trvial json that could come from a fork is loaded correctly"""
source = 'courses/minimal/info.yml'
renderer = DummyRenderer(
course={
'api_version': [0, 0],
'course': {
'title': 'A minimal course',
'sessions': [],
'source_file': source,
}
})
course = models.Course.load_local(
parent=model,
repo_info=get_local_repo_info('/dummy'),
slug='courses/minimal',
renderer=renderer,
)
check_empty_course_attrs(course, source_file=Path(source))
assert_yaml_dump(models.dump(course), 'minimal-course.yml')
def test_course_without_dates(model):
add_test_course(
model, 'courses/without-dates', {
'title':
'A plain vanilla course',
'sessions': [
{
'title': 'A normal session',
'slug': 'normal-session',
},
],
})
course = model.courses['courses/without-dates']
assert course.default_time is None
session = course.sessions['normal-session']
assert session.date is None
assert session.time is None
assert_yaml_dump(models.dump(course), 'session-times/without-dates')
def test_run_with_default_times(model):
add_test_course(
model, 'courses/with-default-times', {
'title': 'Test course with default times',
'default_time': {
'start': '19:00',
'end': '21:00'
},
'sessions': SESSIONS,
})
course = model.courses['courses/with-default-times']
assert course.default_time == {
'start': datetime.time(19, 00, tzinfo=TZINFO),
'end': datetime.time(21, 00, tzinfo=TZINFO),
}
session = course.sessions['normal-session']
assert session.date == datetime.date(2000, 1, 1)
assert session.time == {
'start': datetime.datetime(2000, 1, 1, 19, tzinfo=TZINFO),
'end': datetime.datetime(2000, 1, 1, 21, tzinfo=TZINFO),
}
session = course.sessions['afterparty']
assert session.date == datetime.date(2000, 1, 1)
assert session.time == {
'start': datetime.datetime(2000, 1, 1, 22, tzinfo=TZINFO),
'end': datetime.datetime(2000, 1, 1, 23, tzinfo=TZINFO),
}
session = course.sessions['self-study']
assert session.date == None
assert session.time == None
session = course.sessions['morning-meditation']
assert session.date == None
assert session.time == None
assert_yaml_dump(models.dump(course), 'session-times/with-default-times')
def course_api(course_slug):
try:
course = g.model.courses[course_slug]
except KeyError:
abort(404)
return jsonify(models.dump(course, version=models.API_VERSION))
def test_dump_empty_model():
model = models.Root(schema_url_factory=dummy_schema_url_factory)
assert_yaml_dump(models.dump(model), 'empty-root.yml')
def test_run_years(model):
assert model.run_years == {}
# Add a self-study course. It should not appear in run_years.
add_test_course(model, 'courses/minimal', {
'title': 'A minimal course',
'sessions': [],
})
assert model.run_years == {}
assert sorted(model.courses) == ['courses/minimal']
assert sorted(model.self_study_courses) == ['courses/minimal']
course_minimal = model.courses['courses/minimal']
assert course_minimal.start_date == None
assert course_minimal.end_date == None
# Add a course with a single session. It should appear in its run_year.
add_test_course(
model, '2019/single-session', {
'title':
'A course with a single session',
'sessions': [
{
'title': 'One session',
'slug': 'foo',
'date': '2019-01-05',
'materials': [],
},
],
})
assert sorted(model.courses) == ['2019/single-session', 'courses/minimal']
assert sorted(model.self_study_courses) == ['courses/minimal']
course_2019 = model.courses['2019/single-session']
assert course_2019.start_date.year == 2019
assert course_2019.end_date.year == 2019
assert sorted(model.run_years) == [2019]
assert model.run_years[2019] == {'2019/single-session': course_2019}
# Add a course spanning 3 years. Should appear in all run_years it spans.
# (Even if there are no sessions that year.)
add_test_course(
model, '2017/multi-year', {
'title':
'A course with sessions in years 2017 and 2019',
'sessions': [
{
'title': 'First session, 2017',
'slug': 'one',
'date': '2017-01-05',
'materials': [],
},
{
'title': 'Last session, 2019',
'slug': 'two',
'date': '2019-01-05',
'materials': [],
},
],
})
assert sorted(model.courses) == [
'2017/multi-year',
'2019/single-session',
'courses/minimal',
]
assert sorted(model.self_study_courses) == ['courses/minimal']
course_2017 = model.courses['2017/multi-year']
assert course_2017.start_date.year == 2017
assert course_2017.end_date.year == 2019
assert sorted(model.run_years) == [2017, 2018, 2019]
for year in 2017, 2018:
assert model.run_years[year] == {'2017/multi-year': course_2017}
assert model.run_years[2019] == {
'2017/multi-year': course_2017,
'2019/single-session': course_2019,
}
assert_yaml_dump(models.dump(model), 'run-years/root.yml')
for year, run_year in model.run_years.items():
assert_yaml_dump(models.dump(run_year), f'run-years/{year}.yml')
def _assert(model, filename):
filename += '.v{}.{}.yaml'.format(*version)
assert_yaml_dump(models.dump(model, version=version), filename)
def api():
return jsonify(models.dump(g.model))
def run_year_api(year):
try:
run_year = g.model.run_years[year]
except KeyError:
abort(404)
return jsonify(models.dump(run_year))
def course_api(course_slug):
try:
course = g.model.courses[course_slug]
except KeyError:
abort(404)
return jsonify(models.dump(course))
def api():
return jsonify(models.dump(g.model, version=models.API_VERSION))
def run_year_api(year):
try:
run_year = g.model.run_years[year]
except KeyError:
abort(404)
return jsonify(models.dump(run_year, version=models.API_VERSION))
