headless_lms_server/programs/seed/builder/
course.rs

1use anyhow::{Context, Result};
2use sqlx::{Connection, PgConnection};
3use tracing::log::warn;
4use uuid::Uuid;
5
6use headless_lms_models::{
7    PKeyPolicy, certificate_configuration_to_requirements,
8    certificate_configurations::{self, DatabaseCertificateConfiguration},
9    chatbot_configurations::{self, NewChatbotConf},
10    course_instances::{self, CourseInstance, NewCourseInstance},
11    course_language_groups,
12    course_modules::CourseModule,
13    courses::{self, Course, NewCourse},
14    file_uploads, glossary,
15    pages::{self, NewCoursePage, NewPage},
16    roles::{self, RoleDomain, UserRole},
17};
18use headless_lms_utils::document_schema_processor::GutenbergBlock;
19
20use crate::programs::seed::{
21    builder::{context::SeedContext, module::ModuleBuilder},
22    seed_helpers::get_seed_spec_fetcher,
23};
24
25/// Additional course instance configuration
26#[derive(Debug, Clone)]
27pub struct CourseInstanceConfig {
28    pub name: Option<String>,
29    pub description: Option<String>,
30    pub support_email: Option<String>,
31    pub teacher_in_charge_name: String,
32    pub teacher_in_charge_email: String,
33    pub opening_time: Option<chrono::DateTime<chrono::Utc>>,
34    pub closing_time: Option<chrono::DateTime<chrono::Utc>>,
35    pub instance_id: Option<Uuid>,
36}
37
38/// Generic page configuration for top-level course pages
39#[derive(Debug, Clone)]
40pub struct PageConfig {
41    pub url: String,
42    pub title: String,
43    pub page_number: i32,
44    pub is_hidden: bool,
45    pub content: Option<Vec<headless_lms_utils::document_schema_processor::GutenbergBlock>>,
46}
47
48/// Glossary entry
49#[derive(Debug, Clone)]
50pub struct GlossaryEntry {
51    pub acronym: String,
52    pub definition: String,
53}
54
55/// Certificate configuration
56#[derive(Debug, Clone)]
57pub struct CertificateConfig {
58    pub background_svg_path: String,
59    pub certificate_id: Option<Uuid>,
60}
61
62/// Builder for courses with modules, chapters, pages, and exercises.
63#[derive(Debug, Clone)]
64pub struct CourseBuilder {
65    pub name: String,
66    pub slug: String,
67    pub language_code: String,
68    pub can_add_chatbot: bool,
69    pub description: String,
70    pub default_instance_name: &'static [u8],
71    pub modules: Vec<ModuleBuilder>,
72    pub extra_roles: Vec<(Uuid, UserRole)>,
73    pub course_id: Option<Uuid>,
74    pub instances: Vec<CourseInstanceConfig>,
75    pub chatbot_configs: Vec<NewChatbotConf>,
76    pub pages: Vec<PageConfig>,
77    pub glossary_entries: Vec<GlossaryEntry>,
78    pub certificate_config: Option<CertificateConfig>,
79    pub front_page_content: Option<Vec<GutenbergBlock>>,
80    pub chapter_locking_enabled: bool,
81    pub flagged_answers_skip_manual_review_and_allow_retry: bool,
82    pub flagged_answers_threshold: Option<i32>,
83}
84
85impl CourseBuilder {
86    pub fn new(name: impl Into<String>, slug: impl Into<String>) -> Self {
87        Self {
88            name: name.into(),
89            slug: slug.into(),
90            language_code: "en".into(),
91            can_add_chatbot: false,
92            description: "Sample course.".into(),
93            default_instance_name: b"default-instance",
94            modules: vec![],
95            extra_roles: vec![],
96            course_id: None,
97            instances: vec![],
98            chatbot_configs: vec![],
99            pages: vec![],
100            glossary_entries: vec![],
101            certificate_config: None,
102            front_page_content: None,
103            chapter_locking_enabled: false,
104            flagged_answers_skip_manual_review_and_allow_retry: false,
105            flagged_answers_threshold: None,
106        }
107    }
108
109    /// Enables skipping manual review for flagged answers and allowing retry.
110    pub fn flagged_answers_skip_manual_review_and_allow_retry(mut self, v: bool) -> Self {
111        self.flagged_answers_skip_manual_review_and_allow_retry = v;
112        self
113    }
114
115    /// Sets the number of spam reports needed to trigger reset/manual review.
116    pub fn flagged_answers_threshold(mut self, v: Option<i32>) -> Self {
117        self.flagged_answers_threshold = v;
118        self
119    }
120
121    pub fn chatbot(mut self, v: bool) -> Self {
122        self.can_add_chatbot = v;
123        self
124    }
125    pub fn chapter_locking_enabled(mut self, v: bool) -> Self {
126        self.chapter_locking_enabled = v;
127        self
128    }
129    pub fn desc(mut self, d: impl Into<String>) -> Self {
130        self.description = d.into();
131        self
132    }
133    pub fn language(mut self, lc: impl Into<String>) -> Self {
134        self.language_code = lc.into();
135        self
136    }
137    pub fn module(mut self, m: ModuleBuilder) -> Self {
138        self.modules.push(m);
139        self
140    }
141    pub fn modules<I: IntoIterator<Item = ModuleBuilder>>(mut self, it: I) -> Self {
142        self.modules.extend(it);
143        self
144    }
145    pub fn role(mut self, user_id: Uuid, role: UserRole) -> Self {
146        self.extra_roles.push((user_id, role));
147        self
148    }
149    pub fn course_id(mut self, id: Uuid) -> Self {
150        self.course_id = Some(id);
151        self
152    }
153
154    pub fn instance(mut self, config: CourseInstanceConfig) -> Self {
155        self.instances.push(config);
156        self
157    }
158
159    pub fn chatbot_config(mut self, config: NewChatbotConf) -> Self {
160        if !self.can_add_chatbot {
161            warn!("Can't add chatbot to this course!!!!");
162            return self;
163        }
164        self.chatbot_configs.push(config);
165        self
166    }
167
168    /// Add a top-level page to the course
169    pub fn top_level_page(
170        mut self,
171        url: impl Into<String>,
172        title: impl Into<String>,
173        page_number: i32,
174        is_hidden: bool,
175        content: Option<Vec<headless_lms_utils::document_schema_processor::GutenbergBlock>>,
176    ) -> Self {
177        self.pages.push(PageConfig {
178            url: url.into(),
179            title: title.into(),
180            page_number,
181            is_hidden,
182            content,
183        });
184        self
185    }
186
187    pub fn glossary_entry(
188        mut self,
189        acronym: impl Into<String>,
190        definition: impl Into<String>,
191    ) -> Self {
192        self.glossary_entries.push(GlossaryEntry {
193            acronym: acronym.into(),
194            definition: definition.into(),
195        });
196        self
197    }
198
199    pub fn certificate_config(
200        mut self,
201        background_svg_path: impl Into<String>,
202        certificate_id: Option<Uuid>,
203    ) -> Self {
204        self.certificate_config = Some(CertificateConfig {
205            background_svg_path: background_svg_path.into(),
206            certificate_id,
207        });
208        self
209    }
210
211    /// Set custom content for the course front page. If not set, default content will be used.
212    pub fn front_page_content(mut self, content: Vec<GutenbergBlock>) -> Self {
213        self.front_page_content = Some(content);
214        self
215    }
216
217    /// Seeds the course and all nested content. Returns `(course, default_instance, last_module)`.
218    pub async fn seed(
219        self,
220        conn: &mut PgConnection,
221        cx: &SeedContext,
222    ) -> Result<(Course, CourseInstance, CourseModule)> {
223        let course_id = self.course_id.unwrap_or(cx.base_course_ns);
224
225        let new_course = NewCourse {
226            name: self.name.clone(),
227            organization_id: cx.org,
228            slug: self.slug.clone(),
229            language_code: self.language_code.clone(),
230            teacher_in_charge_name: "admin".into(),
231            teacher_in_charge_email: "admin@example.com".into(),
232            description: self.description.clone(),
233            is_draft: false,
234            is_test_mode: false,
235            is_unlisted: false,
236            copy_user_permissions: false,
237            is_joinable_by_code_only: false,
238            join_code: None,
239            ask_marketing_consent: false,
240            flagged_answers_threshold: Some(self.flagged_answers_threshold.unwrap_or(3)),
241            can_add_chatbot: self.can_add_chatbot,
242        };
243
244        // Create course manually without default module
245        let mut tx = conn.begin().await.context("starting transaction")?;
246
247        let course_language_group_id = course_language_groups::insert(
248            &mut tx,
249            headless_lms_models::PKeyPolicy::Generate,
250            &new_course.slug,
251        )
252        .await?;
253
254        let course_id = courses::insert(
255            &mut tx,
256            headless_lms_models::PKeyPolicy::Fixed(course_id),
257            course_language_group_id,
258            &new_course,
259        )
260        .await
261        .context("inserting course")?;
262
263        let course = courses::get_course(&mut tx, course_id)
264            .await
265            .context("getting course")?;
266
267        for chatbot_conf in self.chatbot_configs {
268            let chatbotconf_id = chatbot_conf.chatbotconf_id.unwrap_or_else(Uuid::new_v4);
269            chatbot_configurations::insert(
270                &mut tx,
271                PKeyPolicy::Fixed(chatbotconf_id),
272                NewChatbotConf {
273                    course_id,
274                    ..chatbot_conf
275                },
276            )
277            .await
278            .context("inserting chatbot configuration for course")?;
279        }
280
281        let mut last_module = None;
282
283        for (i, m) in self.modules.into_iter().enumerate() {
284            last_module = Some(m.seed(&mut tx, cx, course.id, i as i32).await?);
285        }
286
287        for (user_id, role) in self.extra_roles {
288            roles::insert(&mut tx, user_id, role, RoleDomain::Course(course.id))
289                .await
290                .context("inserting course role")?;
291        }
292
293        // Create course instances
294        let mut default_instance = None;
295        for instance_config in self.instances {
296            let instance_id = instance_config.instance_id.unwrap_or_else(Uuid::new_v4);
297            let instance = course_instances::insert(
298                &mut tx,
299                PKeyPolicy::Fixed(instance_id),
300                NewCourseInstance {
301                    course_id: course.id,
302                    name: instance_config.name.as_deref(),
303                    description: instance_config.description.as_deref(),
304                    support_email: instance_config.support_email.as_deref(),
305                    teacher_in_charge_name: &instance_config.teacher_in_charge_name,
306                    teacher_in_charge_email: &instance_config.teacher_in_charge_email,
307                    opening_time: instance_config.opening_time,
308                    closing_time: instance_config.closing_time,
309                },
310            )
311            .await
312            .context("inserting course instance")?;
313
314            // Use the first instance as the default instance for return value
315            if default_instance.is_none() {
316                default_instance = Some(instance);
317            }
318        }
319
320        let default_instance =
321            default_instance.expect("At least one course instance must be provided");
322
323        // Create mandatory front page for the course
324        let default_front_page_content = vec![
325            GutenbergBlock::landing_page_hero_section("Welcome to...", "Subheading"),
326            GutenbergBlock::landing_page_copy_text(
327                "About this course",
328                "This course teaches you xxx.",
329            ),
330            GutenbergBlock::course_objective_section(),
331            GutenbergBlock::empty_block_from_name("moocfi/course-chapter-grid".to_string()),
332            GutenbergBlock::empty_block_from_name("moocfi/top-level-pages".to_string()),
333            GutenbergBlock::empty_block_from_name("moocfi/congratulations".to_string()),
334            GutenbergBlock::empty_block_from_name("moocfi/course-progress".to_string()),
335        ];
336
337        let front_page_blocks = self
338            .front_page_content
339            .unwrap_or(default_front_page_content);
340
341        let course_front_page = NewPage {
342            chapter_id: None,
343            content: front_page_blocks,
344            course_id: Some(course.id),
345            exam_id: None,
346            front_page_of_chapter_id: None,
347            title: course.name.clone(),
348            url_path: String::from("/"),
349            exercises: vec![],
350            exercise_slides: vec![],
351            exercise_tasks: vec![],
352            content_search_language: None,
353        };
354
355        pages::insert_page(
356            &mut tx,
357            course_front_page,
358            cx.teacher,
359            get_seed_spec_fetcher(),
360            crate::domain::models_requests::fetch_service_info,
361        )
362        .await
363        .context("inserting course front page")?;
364
365        // Create top-level pages
366        for page_config in self.pages {
367            let mut course_page = NewCoursePage::new(
368                course.id,
369                page_config.page_number,
370                &page_config.url,
371                &page_config.title,
372            );
373
374            if page_config.is_hidden {
375                course_page = course_page.set_hidden(true);
376            }
377
378            if let Some(content) = page_config.content {
379                course_page = course_page.set_content(content);
380            }
381
382            pages::insert_course_page(&mut tx, &course_page, cx.teacher)
383                .await
384                .context("inserting course page")?;
385        }
386
387        // Add glossary entries
388        for glossary_entry in self.glossary_entries {
389            glossary::insert(
390                &mut tx,
391                &glossary_entry.acronym,
392                &glossary_entry.definition,
393                course.id,
394            )
395            .await
396            .context("inserting glossary entry")?;
397        }
398
399        // Create certificate configuration
400        if let Some(cert_config) = self.certificate_config {
401            let background_svg_file_upload_id = file_uploads::insert(
402                &mut tx,
403                &format!(
404                    "background-{}.svg",
405                    last_module
406                        .as_ref()
407                        .expect("At least one module must be provided")
408                        .id
409                ),
410                &cert_config.background_svg_path,
411                "image/svg+xml",
412                None,
413            )
414            .await
415            .context("inserting certificate background file")?;
416
417            let certificate_id = cert_config
418                .certificate_id
419                .unwrap_or_else(|| cx.v5(b"886d3e22-5007-4371-94d7-e0ad93a2391c"));
420            let configuration = DatabaseCertificateConfiguration {
421                id: certificate_id,
422                certificate_owner_name_y_pos: None,
423                certificate_owner_name_x_pos: None,
424                certificate_owner_name_font_size: None,
425                certificate_owner_name_text_color: None,
426                certificate_owner_name_text_anchor: None,
427                certificate_validate_url_y_pos: None,
428                certificate_validate_url_x_pos: None,
429                certificate_validate_url_font_size: None,
430                certificate_validate_url_text_color: None,
431                certificate_validate_url_text_anchor: None,
432                certificate_date_y_pos: None,
433                certificate_date_x_pos: None,
434                certificate_date_font_size: None,
435                certificate_date_text_color: None,
436                certificate_date_text_anchor: None,
437                certificate_locale: None,
438                paper_size: None,
439                background_svg_path: cert_config.background_svg_path,
440                background_svg_file_upload_id,
441                overlay_svg_path: None,
442                overlay_svg_file_upload_id: None,
443                render_certificate_grade: false,
444                certificate_grade_y_pos: None,
445                certificate_grade_x_pos: None,
446                certificate_grade_font_size: None,
447                certificate_grade_text_color: None,
448                certificate_grade_text_anchor: None,
449            };
450            let database_configuration =
451                certificate_configurations::insert(&mut tx, &configuration)
452                    .await
453                    .context("inserting certificate configuration")?;
454            certificate_configuration_to_requirements::insert(
455                &mut tx,
456                database_configuration.id,
457                Some(
458                    last_module
459                        .as_ref()
460                        .expect("At least one module must be provided")
461                        .id,
462                ),
463            )
464            .await
465            .context("linking certificate configuration to requirements")?;
466        }
467        tx.commit().await.context("committing transaction")?;
468
469        if self.chapter_locking_enabled || self.flagged_answers_skip_manual_review_and_allow_retry {
470            use headless_lms_models::courses::CourseUpdate;
471            let course_update = CourseUpdate {
472                name: course.name.clone(),
473                description: course.description.clone(),
474                is_draft: course.is_draft,
475                is_test_mode: course.is_test_mode,
476                can_add_chatbot: course.can_add_chatbot,
477                is_unlisted: course.is_unlisted,
478                is_joinable_by_code_only: course.is_joinable_by_code_only,
479                ask_marketing_consent: course.ask_marketing_consent,
480                flagged_answers_threshold: self.flagged_answers_threshold.unwrap_or(3),
481                flagged_answers_skip_manual_review_and_allow_retry: self
482                    .flagged_answers_skip_manual_review_and_allow_retry,
483                closed_at: course.closed_at,
484                closed_additional_message: course.closed_additional_message.clone(),
485                closed_course_successor_id: course.closed_course_successor_id,
486                chapter_locking_enabled: self.chapter_locking_enabled,
487            };
488            let updated_course = courses::update_course(conn, course.id, course_update)
489                .await
490                .context("updating course")?;
491            return Ok((
492                updated_course,
493                default_instance,
494                last_module.expect("At least one module must be provided"),
495            ));
496        }
497
498        Ok((
499            course,
500            default_instance,
501            last_module.expect("At least one module must be provided"),
502        ))
503    }
504}
505
506#[cfg(test)]
507mod tests {
508    use crate::programs::seed::builder::module::ModuleBuilder;
509
510    use super::*;
511    use headless_lms_models::roles::UserRole;
512
513    #[test]
514    fn course_builder_new() {
515        let course = CourseBuilder::new("Test Course", "test-course");
516
517        assert_eq!(course.name, "Test Course");
518        assert_eq!(course.slug, "test-course");
519        assert_eq!(course.language_code, "en");
520        assert!(!course.can_add_chatbot);
521        assert_eq!(course.description, "Sample course.");
522        assert_eq!(course.default_instance_name, b"default-instance");
523        assert!(course.modules.is_empty());
524        assert!(course.extra_roles.is_empty());
525        assert!(course.course_id.is_none());
526    }
527
528    #[test]
529    fn course_builder_string_conversion() {
530        let course1 = CourseBuilder::new("String literal", "string-slug");
531        let course2 = CourseBuilder::new(String::from("Owned string"), String::from("owned-slug"));
532
533        assert_eq!(course1.name, "String literal");
534        assert_eq!(course1.slug, "string-slug");
535        assert_eq!(course2.name, "Owned string");
536        assert_eq!(course2.slug, "owned-slug");
537    }
538
539    #[test]
540    fn course_builder_chatbot() {
541        let course = CourseBuilder::new("Test Course", "test-course").chatbot(true);
542        assert!(course.can_add_chatbot);
543
544        let course_disabled = CourseBuilder::new("Test Course", "test-course").chatbot(false);
545        assert!(!course_disabled.can_add_chatbot);
546    }
547
548    #[test]
549    fn course_builder_desc() {
550        let course =
551            CourseBuilder::new("Test Course", "test-course").desc("A comprehensive test course");
552
553        assert_eq!(course.description, "A comprehensive test course");
554
555        let desc_string = String::from("Another description");
556        let course2 = CourseBuilder::new("Test Course", "test-course").desc(desc_string);
557        assert_eq!(course2.description, "Another description");
558    }
559
560    #[test]
561    fn course_builder_language() {
562        let course = CourseBuilder::new("Test Course", "test-course").language("fi-FI");
563
564        assert_eq!(course.language_code, "fi-FI");
565
566        let lang_string = String::from("sv-SE");
567        let course2 = CourseBuilder::new("Test Course", "test-course").language(lang_string);
568        assert_eq!(course2.language_code, "sv-SE");
569    }
570
571    #[test]
572    fn course_builder_module() {
573        let module = ModuleBuilder::new().order(0);
574        let course = CourseBuilder::new("Test Course", "test-course").module(module);
575
576        assert_eq!(course.modules.len(), 1);
577        assert_eq!(course.modules[0].order, Some(0));
578    }
579
580    #[test]
581    fn course_builder_multiple_modules() {
582        let module1 = ModuleBuilder::new().order(0);
583        let module2 = ModuleBuilder::new().order(1);
584        let course = CourseBuilder::new("Test Course", "test-course")
585            .module(module1)
586            .module(module2);
587
588        assert_eq!(course.modules.len(), 2);
589        assert_eq!(course.modules[0].order, Some(0));
590        assert_eq!(course.modules[1].order, Some(1));
591    }
592
593    #[test]
594    fn course_builder_role() {
595        let user_id = Uuid::new_v4();
596        let course =
597            CourseBuilder::new("Test Course", "test-course").role(user_id, UserRole::Teacher);
598
599        assert_eq!(course.extra_roles.len(), 1);
600        assert_eq!(course.extra_roles[0].0, user_id);
601        assert_eq!(course.extra_roles[0].1, UserRole::Teacher);
602    }
603
604    #[test]
605    fn course_builder_multiple_roles() {
606        let user1_id = Uuid::new_v4();
607        let user2_id = Uuid::new_v4();
608        let course = CourseBuilder::new("Test Course", "test-course")
609            .role(user1_id, UserRole::Teacher)
610            .role(user2_id, UserRole::MaterialViewer);
611
612        assert_eq!(course.extra_roles.len(), 2);
613        assert_eq!(course.extra_roles[0].0, user1_id);
614        assert_eq!(course.extra_roles[0].1, UserRole::Teacher);
615        assert_eq!(course.extra_roles[1].0, user2_id);
616        assert_eq!(course.extra_roles[1].1, UserRole::MaterialViewer);
617    }
618
619    #[test]
620    fn course_builder_course_id() {
621        let course_id = Uuid::new_v4();
622        let course = CourseBuilder::new("Test Course", "test-course").course_id(course_id);
623
624        assert_eq!(course.course_id, Some(course_id));
625    }
626
627    #[test]
628    fn course_builder_fluent_interface() {
629        let user_id = Uuid::new_v4();
630        let course_id = Uuid::new_v4();
631        let module = ModuleBuilder::new().order(0);
632
633        let course = CourseBuilder::new("Advanced Course", "advanced-course")
634            .desc("A comprehensive advanced course")
635            .language("fi-FI")
636            .chatbot(true)
637            .module(module)
638            .role(user_id, UserRole::Teacher)
639            .course_id(course_id);
640
641        assert_eq!(course.name, "Advanced Course");
642        assert_eq!(course.slug, "advanced-course");
643        assert_eq!(course.description, "A comprehensive advanced course");
644        assert_eq!(course.language_code, "fi-FI");
645        assert!(course.can_add_chatbot);
646        assert_eq!(course.modules.len(), 1);
647        assert_eq!(course.extra_roles.len(), 1);
648        assert_eq!(course.course_id, Some(course_id));
649    }
650
651    #[test]
652    fn course_builder_default_values() {
653        let course = CourseBuilder::new("Minimal Course", "minimal");
654
655        assert_eq!(course.language_code, "en");
656        assert!(!course.can_add_chatbot);
657        assert_eq!(course.description, "Sample course.");
658        assert_eq!(course.default_instance_name, b"default-instance");
659        assert!(course.modules.is_empty());
660        assert!(course.extra_roles.is_empty());
661        assert!(course.course_id.is_none());
662    }
663
664    #[test]
665    fn course_builder_empty_strings() {
666        let course = CourseBuilder::new("", "");
667
668        assert_eq!(course.name, "");
669        assert_eq!(course.slug, "");
670        assert_eq!(course.language_code, "en");
671        assert_eq!(course.description, "Sample course.");
672    }
673
674    #[test]
675    fn course_builder_method_chaining_order() {
676        let course1 = CourseBuilder::new("Course 1", "course-1")
677            .chatbot(true)
678            .desc("Description 1")
679            .language("fi-FI");
680
681        let course2 = CourseBuilder::new("Course 2", "course-2")
682            .language("fi-FI")
683            .desc("Description 2")
684            .chatbot(true);
685
686        assert_eq!(course1.can_add_chatbot, course2.can_add_chatbot);
687        assert_eq!(course1.language_code, course2.language_code);
688        assert_eq!(course1.description, "Description 1");
689        assert_eq!(course2.description, "Description 2");
690    }
691
692    #[test]
693    fn course_builder_front_page_content() {
694        let custom_content = vec![
695            GutenbergBlock::landing_page_hero_section("Custom Welcome", "Custom Subheading"),
696            GutenbergBlock::course_objective_section(),
697        ];
698
699        let course = CourseBuilder::new("Test Course", "test-course")
700            .front_page_content(custom_content.clone());
701
702        assert_eq!(course.front_page_content, Some(custom_content));
703    }
704
705    #[test]
706    fn course_builder_front_page_content_default() {
707        let course = CourseBuilder::new("Test Course", "test-course");
708
709        assert_eq!(course.front_page_content, None);
710    }
711
712    #[test]
713    fn course_builder_top_level_page() {
714        let course = CourseBuilder::new("Test Course", "test-course")
715            .top_level_page("/welcome", "Welcome Page", 1, false, None)
716            .top_level_page("/hidden", "Hidden Page", 2, true, None);
717
718        assert_eq!(course.pages.len(), 2);
719        assert_eq!(course.pages[0].url, "/welcome");
720        assert_eq!(course.pages[0].title, "Welcome Page");
721        assert_eq!(course.pages[0].page_number, 1);
722        assert!(!course.pages[0].is_hidden);
723        assert_eq!(course.pages[0].content, None);
724
725        assert_eq!(course.pages[1].url, "/hidden");
726        assert_eq!(course.pages[1].title, "Hidden Page");
727        assert_eq!(course.pages[1].page_number, 2);
728        assert!(course.pages[1].is_hidden);
729        assert_eq!(course.pages[1].content, None);
730    }
731
732    #[test]
733    fn course_builder_top_level_page_with_content() {
734        let content = vec![];
735        let course = CourseBuilder::new("Test Course", "test-course").top_level_page(
736            "/content",
737            "Content Page",
738            1,
739            false,
740            Some(content.clone()),
741        );
742
743        assert_eq!(course.pages.len(), 1);
744        assert_eq!(course.pages[0].url, "/content");
745        assert_eq!(course.pages[0].title, "Content Page");
746        assert_eq!(course.pages[0].page_number, 1);
747        assert!(!course.pages[0].is_hidden);
748        assert_eq!(course.pages[0].content, Some(content));
749    }
750
751    #[test]
752    fn course_builder_multiple_top_level_pages() {
753        let course = CourseBuilder::new("Test Course", "test-course")
754            .top_level_page("/welcome", "Welcome", 1, false, None)
755            .top_level_page("/about", "About", 2, false, None)
756            .top_level_page("/secret", "Secret", 3, true, None);
757
758        assert_eq!(course.pages.len(), 3);
759        assert_eq!(course.pages[0].url, "/welcome");
760        assert_eq!(course.pages[1].url, "/about");
761        assert_eq!(course.pages[2].url, "/secret");
762        assert!(course.pages[2].is_hidden);
763    }
764}
headless_lms_server/programs/seed/builder/course.rs

headless_lms_server/programs/seed/builder/
course.rs
