one more folder change

src/features/local/utils/tests/fileStorage.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { promises as fs } from "fs";
+import { fileStorageService } from "../fileStorageService";
+import {
+  LocalCourseSettings,
+  DayOfWeek,
+} from "@/features/local/course/localCourseSettings";
+import {
+  createModuleFile,
+  getModuleNamesFromFiles,
+} from "@/features/local/modules/moduleRouter";
+
+describe("FileStorageTests", () => {
+  beforeEach(async () => {
+    const storageDirectory =
+      process.env.STORAGE_DIRECTORY ?? "/tmp/canvasManagerTests";
+    process.env.GLOBAL_SETTINGS = `courses:
+      - path: test empty course
+        name: test empty course`;
+    try {
+      await fs.access(storageDirectory);
+      await fs.rm(storageDirectory, { recursive: true });
+    } catch {}
+    await fs.mkdir(storageDirectory, { recursive: true });
+  });
+
+  it("course settings can be saved and loaded", async () => {
+    const name = "test empty course";
+    await fileStorageService.createCourseFolderForTesting(name);
+    const settings: LocalCourseSettings = {
+      name,
+      assignmentGroups: [],
+      daysOfWeek: [DayOfWeek.Monday, DayOfWeek.Wednesday],
+      startDate: "07/09/2024 23:59:00",
+      endDate: "07/09/2024 23:59:00",
+      defaultDueTime: { hour: 1, minute: 59 },
+      canvasId: 0,
+      defaultAssignmentSubmissionTypes: [],
+      defaultFileUploadTypes: [],
+      holidays: [],
+      assets: [],
+    };
+
+    await fileStorageService.settings.updateCourseSettings(name, settings);
+
+    const loadedSettings = await fileStorageService.settings.getCourseSettings({
+      name,
+      path: name,
+    });
+
+    expect(loadedSettings).toEqual(settings);
+  });
+
+  it("empty course modules can be created", async () => {
+    const courseName = "test empty course";
+    const moduleName = "test module 1";
+
+    await createModuleFile(courseName, moduleName);
+
+    const moduleNames = await getModuleNamesFromFiles(courseName);
+
+    expect(moduleNames).toContain(moduleName);
+  });
+});

src/features/local/utils/tests/fileStorageParsingErrors.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { promises as fs } from "fs";
+import { fileStorageService } from "../fileStorageService";
+import { basePath } from "../fileSystemUtils";
+import { courseItemFileStorageService } from "@/features/local/course/courseItemFileStorageService";
+import { createModuleFile } from "@/features/local/modules/moduleRouter";
+
+describe("FileStorageTests", () => {
+  beforeEach(async () => {
+    const storageDirectory =
+      process.env.STORAGE_DIRECTORY ?? "/tmp/canvasManagerTests";
+    process.env.GLOBAL_SETTINGS = `courses:
+      - path: testCourse
+        name: testCourse`;
+    try {
+      await fs.access(storageDirectory);
+      await fs.rm(storageDirectory, { recursive: true });
+    } catch {}
+    await fs.mkdir(storageDirectory, { recursive: true });
+  });
+
+  it("invalid quizzes do not get loaded", async () => {
+    const courseName = "testCourse";
+    const moduleName = "testModule";
+    const validQuizMarkdown = `Name: validQuiz
+LockAt: 08/28/2024 23:59:00
+DueAt: 08/28/2024 23:59:00
+Password: 
+ShuffleAnswers: true
+ShowCorrectAnswers: false
+OneQuestionAtATime: false
+AssignmentGroup: Assignments
+AllowedAttempts: -1
+Description: Repeat this quiz until you can complete it without notes/help.
+---
+Points: 0.25
+
+An empty string is 
+
+a) truthy
+*b) falsy
+`;
+    const invalidQuizMarkdown = "name: testQuiz\n---\nnot a quiz";
+    await fileStorageService.createCourseFolderForTesting(courseName);
+    await createModuleFile(courseName, moduleName);
+
+    await fs.mkdir(`${basePath}/${courseName}/${moduleName}/quizzes`, {
+      recursive: true,
+    });
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/quizzes/testQuiz.md`,
+      invalidQuizMarkdown
+    );
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/quizzes/validQuiz.md`,
+      validQuizMarkdown
+    );
+
+    const quizzes = await courseItemFileStorageService.getItems({
+      courseName,
+      moduleName,
+      type: "Quiz",
+    });
+    const quizNames = quizzes.map((q) => q.name);
+
+    expect(quizNames).not.includes("testQuiz");
+    expect(quizNames).include("validQuiz");
+  });
+
+  it("invalid assignments dont get loaded", async () => {
+    const courseName = "testCourse";
+    const moduleName = "testModule";
+    const validAssignmentMarkdown = `Name: testAssignment
+LockAt: 09/19/2024 23:59:00
+DueAt: 09/19/2024 23:59:00
+AssignmentGroupName: Assignments
+SubmissionTypes:
+- online_text_entry
+- online_upload
+AllowedFileUploadExtensions:
+- pdf
+---
+this is the test description
+## Rubric
+- 2pts: animation has at least 5 transition states
+`;
+    const invalidAssignment = "name: invalidAssignment\n---\nnot an assignment";
+    await fileStorageService.createCourseFolderForTesting(courseName);
+    await createModuleFile(courseName, moduleName);
+
+    await fs.mkdir(`${basePath}/${courseName}/${moduleName}/assignments`, {
+      recursive: true,
+    });
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/assignments/testAssignment.md`,
+      validAssignmentMarkdown
+    );
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/assignments/invalidAssignment.md`,
+      invalidAssignment
+    );
+
+    const assignments = await courseItemFileStorageService.getItems({
+      courseName,
+      moduleName,
+      type: "Assignment",
+    });
+    const assignmentNames = assignments.map((q) => q.name);
+
+    expect(assignmentNames).not.includes("invalidAssignment");
+    expect(assignmentNames).include("testAssignment");
+  });
+
+  it("invalid pages dont get loaded", async () => {
+    const courseName = "testCourse";
+    const moduleName = "testModule";
+    const validPageMarkdown = `Name: validPage
+DueDateForOrdering: 08/31/2024 23:59:00
+---
+# Deploying React
+`;
+    const invalidPageMarkdown = `Name: invalidPage
+DueDateFo59:00
+---
+# Deploying React`;
+    await fileStorageService.createCourseFolderForTesting(courseName);
+    await createModuleFile(courseName, moduleName);
+
+    await fs.mkdir(`${basePath}/${courseName}/${moduleName}/pages`, {
+      recursive: true,
+    });
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/pages/validPage.md`,
+      validPageMarkdown
+    );
+    await fs.writeFile(
+      `${basePath}/${courseName}/${moduleName}/pages/invalidPage.md`,
+      invalidPageMarkdown
+    );
+
+    const pages = await courseItemFileStorageService.getItems({
+      courseName,
+      moduleName,
+      type: "Page",
+    });
+    const assignmentNames = pages.map((q) => q.name);
+
+    expect(assignmentNames).include("validPage");
+    expect(assignmentNames).not.includes("invalidPage");
+  });
+});

src/features/local/utils/tests/lectureStorage.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { lectureToString } from "../../lectures/lectureUtils";
+import { parseLecture } from "../../lectures/lectureUtils";
+import { Lecture } from "@/features/local/lectures/lectureModel";
+
+describe("can parse and stringify lectures", () => {
+  it("can parse lecture", () => {
+    const rawLecture = `
+Name: some name
+Date: 6/22/2024
+---
+this is the lecture
+
+
+content`;
+    const parsed = parseLecture(rawLecture);
+    expect(parsed.name).toBe("some name");
+    expect(parsed.date).toBe("6/22/2024");
+    expect(parsed.content).toBe(`this is the lecture
+
+
+content`);
+  });
+
+  it("parsing and stringification is deterministic", () => {
+    const lecture: Lecture = {
+      name: "test lecture",
+      date: "06/*22/2024",
+      content: `some content
+- with
+- a
+- list`,
+    };
+    const rawLecture = lectureToString(lecture);
+    const parsedLecture = parseLecture(rawLecture);
+    expect(parsedLecture).toStrictEqual(lecture);
+  });
+});