// SPDX-License-Identifier: Prosperity-3.0.0 // Copyright Scienting // Source: https://git.scient.ing/education/coursebank //! The 2.1 schema against its specification in `docs/design/2.1/`. //! //! The examples there are the fixtures, read in place, so the specification and //! these tests cannot drift apart: `examples/v20/` must load unchanged, //! `examples/v21/` uses every new field, and `schemas/` is the JSON Schema each //! generated file must equal. mod common; use std::path::PathBuf; use common::{design, scratch, v21_course}; use coursebank::catalog::Catalog; use coursebank::course::CourseFile; use coursebank::jsonschema::{self, Kind}; use serde_json::Value; /// The JSON pointers at which two values differ. fn differences(path: &str, generated: &Value, target: &Value, out: &mut Vec) { match (generated, target) { (Value::Object(a), Value::Object(b)) => { for key in a.keys().chain(b.keys().filter(|k| !a.contains_key(*k))) { let here = format!("{path}/{}", key.replace('~', "~0").replace('/', "~1")); match (a.get(key), b.get(key)) { (Some(x), Some(y)) => differences(&here, x, y, out), (Some(_), None) => out.push(format!("{here} (only generated)")), (None, Some(_)) => out.push(format!("{here} (only in the target)")), (None, None) => {} } } } (Value::Array(a), Value::Array(b)) if a.len() == b.len() => { for (i, (x, y)) in a.iter().zip(b).enumerate() { differences(&format!("{path}/{i}"), x, y, out); } } _ if generated == target => {} _ => out.push(path.to_string()), } } /// Differences that are known and kept, with the reason. /// /// Both are spellings in 2.0 descriptions that the code already had before 2.1: /// `schemas-original/` was generated by a build that spelled them the American /// way, and the 2.1 targets were built from it. const KNOWN: &[(&str, &str)] = &[ ( "calibration.schema.json", "/properties/items/additionalProperties/properties/variants/items/properties/option_stats\ /description", ), ( "course.schema.json", "/properties/policy/properties/grade_scale/items/properties/group/description", ), ]; #[test] fn every_generated_schema_matches_its_target() { let mut unexpected = Vec::new(); for kind in Kind::ALL { let name = kind.filename(); let text = std::fs::read_to_string(design().join("schemas").join(name)) .unwrap_or_else(|e| panic!("{name}: {e}")); let target: Value = serde_json::from_str(&text).unwrap(); let mut found = Vec::new(); differences("", &jsonschema::schema(kind), &target, &mut found); for pointer in found { if !KNOWN.iter().any(|(file, p)| *file == name && *p == pointer) { unexpected.push(format!("{name}: {pointer}")); } } } assert!( unexpected.is_empty(), "generated schemas differ from docs/design/2.1/schemas:\n {}", unexpected.join("\n ") ); } #[test] fn the_known_differences_are_still_there() { // If one of these is fixed, the allow-list should shrink with it. for (file, pointer) in KNOWN { let kind = Kind::ALL .into_iter() .find(|k| k.filename() == *file) .unwrap(); let generated = jsonschema::schema(kind); let text = std::fs::read_to_string(design().join("schemas").join(file)).unwrap(); let target: Value = serde_json::from_str(&text).unwrap(); assert_ne!( generated.pointer(pointer), target.pointer(pointer), "{file}{pointer}" ); } } /// The 2.0 fragments, completed into a course with the ids they cite. fn v20_course(tag: &str) -> PathBuf { let root = scratch(tag); std::fs::write( root.join("course.yaml"), "schema_version: '2.0'\ncourse: { code: BIOSC 1540, title: Computational Biology, term: \ 2026f }\nunits: [{ id: u1, title: Sequences and alignment }]\nreferences:\n \ durbin1998biological: { title: Biological Sequence Analysis }\n", ) .unwrap(); std::fs::create_dir_all(root.join("lectures")).unwrap(); std::fs::create_dir_all(root.join("objectives")).unwrap(); let v20 = design().join("examples/v20"); std::fs::copy(v20.join("l09.yaml"), root.join("lectures/l09.yaml")).unwrap(); std::fs::copy( v20.join("lo-alignment-recurrence.yaml"), root.join("objectives/lo-alignment-recurrence.yaml"), ) .unwrap(); std::fs::write( root.join("objectives/lo-alignment-scoring.yaml"), "learning_objectives:\n lo-alignment-scoring: { text: Score an alignment., unit: u1, \ level_ceiling: 3 }\nlearning_targets:\n t-align-matrix-terms: { text: Define the \ matrix., objective: lo-alignment-scoring, level_ceiling: 1 }\n \ t-align-local-vs-global: { text: Compare local and global., objective: \ lo-alignment-scoring, level_ceiling: 2 }\n", ) .unwrap(); root } #[test] fn the_2_0_fragments_load_and_validate_unchanged() { let root = v20_course("v20-load"); let course = CourseFile::load_dir(&root).expect("2.0 fragments load"); let issues = course.validate(); assert!(issues.is_empty(), "{issues:#?}"); assert!(course.terms.is_empty() && course.equations.is_empty()); } #[test] fn the_2_1_example_loads_every_new_field() { let root = v21_course("v21-load"); let catalog = Catalog::load(&root).expect("the 2.1 example loads"); let course = &catalog.course; assert_eq!(course.terms.len(), 8); assert_eq!(course.equations.len(), 1); assert_eq!(course.values.len(), 2); assert_eq!(course.misconceptions.len(), 2); // Where each entry came from: the objective file, or glossary.yaml. assert_eq!( course.origin("term-gap").map(|(_, p)| p.to_path_buf()), Some(PathBuf::from("objectives/lo-alignment-scoring.yaml")) ); assert_eq!( course .origin("val-per-decade") .map(|(_, p)| p.to_path_buf()), Some(PathBuf::from("glossary.yaml")) ); let target = &course.learning_targets["t-align-fill-matrix"]; assert!(target.explanation.is_some()); assert_eq!(target.equations, vec!["eq-global-recurrence".to_string()]); assert!(target.authoring.as_ref().unwrap().ceiling_item.is_some()); let lecture = &course.lectures["l09"]; assert!(lecture.description.is_some()); assert_eq!(lecture.materials.len(), 3); assert_eq!(lecture.readings[0].minutes, Some(40)); let policy = &course.policy; assert_eq!(policy.levels["3"].name, "Application"); assert_eq!(policy.blueprints["module"].level_counts["2"], 18); assert_eq!(policy.target_text_forbid.len(), 3); assert_eq!( policy.exam_conditions.as_ref().unwrap().seconds_per_item, Some(120.0) ); let item = catalog.get("q-align-which-scores-higher").expect("item"); assert_eq!( item.item.options[1].misconception_id.as_deref(), Some("mis-only-matches-count") ); } #[test] fn the_migration_output_loads_as_a_glossary_fragment() { let root = scratch("migration-output"); std::fs::write( root.join("course.yaml"), "course: { code: X, title: Y, term: Z }\nreferences:\n KKW: { title: The Molecules of \ Life }\n", ) .unwrap(); std::fs::copy( design().join("examples/migration/glossary.expected.yaml"), root.join("glossary.yaml"), ) .unwrap(); let course = CourseFile::load_dir(&root).expect("loads"); assert!(course.terms.contains_key("term-decade")); assert!(course.values.contains_key("val-per-decade")); } #[test] fn a_lecture_file_may_not_define_glossary_entries() { let root = v20_course("v20-lecture-glossary"); std::fs::write( root.join("lectures/l10.yaml"), "lectures:\n l10: { title: Ten }\nterms:\n term-x: { term: x, definition: An x. }\n", ) .unwrap(); let message = CourseFile::load_dir(&root).unwrap_err().to_string(); assert!(message.contains("may not define `terms`"), "{message}"); } #[test] fn a_glossary_id_defined_twice_names_both_files() { let root = v21_course("v21-dup"); std::fs::write( root.join("glossary.yaml"), "terms:\n term-gap: { term: gap, definition: A dash. }\n", ) .unwrap(); let message = CourseFile::load_dir(&root).unwrap_err().to_string(); assert!( message.contains("term `term-gap` is defined in two places"), "{message}" ); assert!(message.contains("glossary.yaml"), "{message}"); assert!( message.contains("objectives/lo-alignment-scoring.yaml"), "{message}" ); }