@ueu/ueu-canvas 0.0.2

package/src/course/__tests__/Course.test.ts

@@ -0,0 +1,91 @@
+import {mockAssignmentData} from "../../content/__mocks__/mockContentData";
+import {mockCourseData} from "../__mocks__/mockCourseData";
+import {
+    Course
+} from "../Course";
+import mockTabData from "../../__mocks__/mockTabData";
+import {assignmentDataGen} from "@/content/assignments";
+import {baseCourseCode, parseCourseCode, stringIsCourseCode} from "@/course/code";
+import {fetchJson} from "@/fetch/fetchJson";
+import {returnMockAsyncGen} from "@/__mocks__/utils";
+jest.mock('@/fetch/fetchJson')
+
+jest.mock('@/content/assignments', () => ({
+    ...jest.requireActual('@/content/assignments'),
+    assignmentDataGen: jest.fn(),
+}))
+
+
+describe('get content', () => {
+    const config = {};
+    test('Gets assignments', async () => {
+        const id = Math.floor(Math.random() * 1000);
+        const assignmentDatas = [{...mockAssignmentData, id}];
+        const course = new Course(mockCourseData);
+        (assignmentDataGen as jest.Mock).mockImplementation(returnMockAsyncGen(assignmentDatas))
+
+        const extractedAssignments = await course.getAssignments(config);
+        expect(extractedAssignments.length).toEqual(assignmentDatas.length);
+        expect(extractedAssignments[0].rawData).toEqual(assignmentDatas[0])
+    })
+})
+
+
+
+
+test('get tabs', async () => {
+    const fetchJsonMock = fetchJson as jest.Mock;
+    const mockCourse = new Course({...mockCourseData, id: 1});
+    const config = {};
+    const mockTabsData = [{...mockTabData, label: 'a'}];
+    fetchJsonMock.mockResolvedValue(mockTabsData);
+    const tabs = await mockCourse.getTabs(config);
+    expect(fetchJsonMock).toHaveBeenCalledWith(`/api/v1/courses/${mockCourse.id}/tabs`, config);
+    expect(tabs).toEqual(mockTabsData);
+
+})
+
+
+
+describe('parseCourseCode', () => {
+  test('parses course code with prefix', () => {
+    expect(parseCourseCode('BP_TEST123')).toBe('BP_TEST123');
+    expect(parseCourseCode('BPTEST123')).toBe('BP_TEST123');
+  });
+
+  test('parses course code without prefix', () => {
+    expect(parseCourseCode('TEST123')).toBe('TEST123');
+    expect(parseCourseCode('TEST123')).not.toBe('TEST123_TEST123');
+  });
+
+  test('returns null for invalid course codes', () => {
+    expect(parseCourseCode('BP')).toBeNull();
+    expect(parseCourseCode('_123')).toBeNull();
+  });
+});
+
+describe('baseCourseCode', () => {
+  test('returns base course code without prefix', () => {
+    expect(baseCourseCode('DEV_TEST123')).toBe('TEST123');
+    expect(baseCourseCode('TEST123')).toBe('TEST123');
+  });
+
+  test('returns null for invalid course codes', () => {
+    expect(baseCourseCode('BP')).toBeNull();
+    expect(baseCourseCode('_123')).toBeNull();
+  });
+});
+
+describe('stringIsCourseCode', () => {
+  test('returns match for valid course codes', () => {
+    expect(stringIsCourseCode('BP_TEST123')).toBeTruthy();
+    expect(stringIsCourseCode('BPTEST123')).toBeTruthy();
+  });
+
+  test('returns null for invalid course codes', () => {
+    expect(stringIsCourseCode('BP')).toBeNull();
+    expect(stringIsCourseCode('_123')).toBeNull();
+  });
+});
+
+

package/src/course/__tests__/blueprint.test.ts

@@ -0,0 +1,292 @@
+//We should really write integration tests for these eventually rather than just unit tests
+
+
+import {deFormDataify, ICanvasCallConfig, range} from "../../canvasUtils";
+import {
+    getBlueprintsFromCode, setAsBlueprint, unSetAsBlueprint, lockBlueprint, genBlueprintDataForCode
+} from "../blueprint";
+import {mockCourseData} from "../__mocks__/mockCourseData";
+import fetchMock, {FetchMock} from "jest-fetch-mock";
+import {IAccountData, IModuleData} from "../../canvasDataDefs";
+import {mockTermData} from "../../__mocks__/mockTermData";
+import {mockAccountData} from "../../__mocks__/mockAccountData";
+import assert from "assert";
+import mockModuleData, {mockModuleItemData} from "../__mocks__/mockModuleData";
+import {Course} from "../Course";
+import {GetCoursesFromAccountOptions} from "@/course/courseTypes";
+import * as courseApi from '@/course/toolbox';
+import * as fetchApi from '@/fetch/utils'
+import {ICourseData} from "@/types";
+import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
+import {mockAsyncGen, returnMockAsyncGen} from "@/__mocks__/utils";
+import {baseCourseCode, MalformedCourseCodeError} from "@/course/code";
+import {fetchJson} from "@/fetch/fetchJson";
+
+
+jest.mock('@/fetch/fetchJson');
+jest.mock('@/fetch/getPagedDataGenerator');
+fetchMock.enableMocks();
+
+const getCourseGenerator = jest.spyOn(courseApi, 'getCourseGenerator')
+const getCourseDataGenerator = jest.spyOn(courseApi, 'getCourseDataGenerator')
+const fetchGetConfig = jest.spyOn(fetchApi, 'fetchGetConfig')
+
+
+function getDummyBlueprintCourse(blueprint: boolean, id: number = 0) {
+    let out: IBlueprintCourse;
+    out = new Course({
+        ...mockCourseData,
+        id,
+        name: 'BP_TEST000',
+        courseCode: 'BP_TEST000',
+        blueprint,
+        getAssociatedCourses: () => getSections(out.id)
+    })
+    return out;
+}
+
+test("Testing get associated courses logic", async () => {
+    const mockData = [...range(0, 9)].map(i => {
+        return {...mockCourseData, id: i}
+    });
+
+    (getPagedDataGenerator as jest.Mock).mockImplementation(returnMockAsyncGen(mockData.map(a => new Course(a))));
+    const courses = await getSections(getDummyBlueprintCourse(true, 0).id)
+    const courseIds = courses.map(course => course.id).toSorted();
+    expect(courseIds).toStrictEqual([...range(0, 9)]);
+
+})
+
+
+describe("Testing blueprint retirement", () => {
+    it('throws an error when course is not named as the base blueprint', async () => {
+        const course = new Course({...mockCourseData, course_code:"BP-xxx-TEST104" , blueprint: false});
+        await expect(async () => await retireBlueprint(course, 'XXXXXXX')).rejects.toThrow(NotABlueprintError)
+    })
+    it('throws an error when course code is malformed', async () => {
+        const course = new Course({...mockCourseData, course_code: "X12375"});
+        await expect(async () => await retireBlueprint(course, 'XXXXXXX')).rejects.toThrow(MalformedCourseCodeError)
+    })
+    it('goes successfully through process',  async() => {
+        const termName = 'DE8W03.11.24';
+        const mockBpData = {
+            ...mockCourseData,
+            id: 0,
+            blueprint: true,
+            course_code: 'BP_TEST000',
+            name: 'BP_TEST000: Testing with Tests'
+        };
+        const notBpMockBpData = {...mockBpData, blueprint: false};
+        const badNameMockBpData = {...mockBpData, course_code: `BP-${termName}_TEST000`}
+        const mockBlueprint = new Course(mockBpData);
+        const notBpMockBlueprint: Course = new Course(notBpMockBpData);
+        const badNameMockBlueprint: Course = new Course(badNameMockBpData);
+        await expect(retireBlueprint(badNameMockBlueprint, termName)).rejects.toThrow("This blueprint is not named BP_")
+
+        const mockAssociatedCourseData: ICourseData[] = [{
+            ...mockCourseData,
+            id: 1,
+            course_code: `${termName}_TEST000-01`,
+            enrollment_term_id: [10],
+        }];
+
+        (getPagedDataGenerator as jest.Mock).mockImplementationOnce(returnMockAsyncGen(mockAssociatedCourseData))
+        const sections = await mockBlueprint.getAssociatedCourses();
+        (getPagedDataGenerator as jest.Mock).mockImplementationOnce(returnMockAsyncGen([{
+            ...mockAccountData,
+            id: 2,
+            root_account_id: null
+        }]));
+        sections.forEach(section => section.getTerm = jest.fn(async () => (new Term({
+            ...mockTermData,
+            id: 10,
+            name: termName
+        }))))
+        const derivedTermName = await getTermNameFromSections(sections);
+        expect(derivedTermName).toBe(termName);
+
+
+        mockBlueprint.saveData = jest.fn();
+        const config: ICanvasCallConfig = {};
+        await retireBlueprint(mockBlueprint, derivedTermName, config);
+
+
+        expect(mockBlueprint.saveData).toHaveBeenCalledWith({
+            course: {
+                course_code: `BP-${termName}_TEST000`,
+                name: `BP-${termName}_TEST000: Testing with Tests`
+            }
+        }, config)
+    })
+})
+
+describe('getBlueprintFromCode', () => {
+    let dummyDev: Course;
+
+    beforeEach(() => {
+        dummyDev = new Course({...mockCourseData, name: 'DEV_TEST000', course_code: 'DEV_TEST000'})
+    })
+
+    test("Returns null when there's no BP", async () => {
+        (getCourseGenerator as jest.Mock).mockReturnValue(mockAsyncGen([]))
+        const bp = dummyDev.parsedCourseCode && await getBlueprintsFromCode(dummyDev.parsedCourseCode, [0]);
+        expect(bp).toStrictEqual([]);
+    })
+
+    test("Searches for BP from a dev course", async () => {
+        (getCourseGenerator as jest.Mock).mockImplementation((url: string) => {
+            const bpCode = `BP_${baseCourseCode(url)}`;
+            return mockAsyncGen([
+                {...mockCourseData, name: bpCode, course_code: bpCode, blueprint: true}
+            ].map(a => new Course(a)))
+        })
+
+        const [bp] = dummyDev.parsedCourseCode && await getBlueprintsFromCode(dummyDev.parsedCourseCode, [0]) || [];
+        expect(bp).toBeInstanceOf(Course);
+        assert(typeof bp === 'object');
+        expect(bp?.isBlueprint()).toBe(true);
+        expect(bp?.courseCode).toBe('BP_TEST000');
+
+    })
+
+    test("Searches for BP from a section", async () => {
+        fetchMock.once(mockBpResponse)
+        const dummyCourse = new Course({
+            ...mockCourseData,
+            name: 'DE8W12.4.26_TEST000',
+            course_code: 'DE8W12.4.26_DEV_TEST000'
+        })
+        const [bp] = dummyCourse.parsedCourseCode && await getBlueprintsFromCode(dummyCourse.parsedCourseCode, [0]) || [];
+        expect(bp).toBeInstanceOf(Course);
+        assert(typeof bp === 'object');
+        expect(bp?.isBlueprint()).toBe(true);
+        expect(bp?.courseCode).toBe('BP_TEST000');
+
+    })
+
+})
+
+test("setAsBlueprint", async () => {
+    let responseData: ICourseData;
+    const payload = {
+        course: {
+            blueprint: true,
+            use_blueprint_restrictions_by_object_type: 0,
+            blueprint_restrictions: {
+                content: 1,
+                points: 1,
+                due_dates: 1,
+                availability_dates: 1,
+            }
+        }
+    }
+
+
+    const config: ICanvasCallConfig = {};
+    responseData = await setAsBlueprint(0, config)
+    expect(fetchJson).toHaveBeenCalledWith(`/api/v1/courses/0`, apiWriteConfig('PUT', payload, config))
+})
+
+test("unSetAsBlueprint", async () => {
+    const payload = {
+        course: {
+            blueprint: false
+        }
+    };
+    const config = {
+        queryParams: {
+            include: ['a']
+        }
+    };
+    await unSetAsBlueprint(0, config);
+    expect(fetchJson).toHaveBeenCalledWith(`/api/v1/courses/0`, apiWriteConfig('PUT', payload, config))
+})
+
+
+test('lock blueprint', async () => {
+    (fetchJson as jest.Mock).mockClear()
+    const modules: IModuleData[] = [];
+    const moduleCount = 10;
+    const itemCount = 6;
+    for (let i = 0; i < moduleCount; i++) {
+        modules.push({
+            ...mockModuleData,
+            name: `Week ${i}`,
+            items: [...range(0, itemCount - 1)].map(j => ({
+                ...mockModuleItemData,
+                content_id: i * 100 + j,
+                name: `Week ${i} Assignment ${j}`
+            }))
+        })
+    }
+    (fetchJson as jest.Mock).mockResolvedValue({})
+    await lockBlueprint(0, modules);
+    const contentIds: number[] = [];
+    modules.forEach(module => module.items.forEach(item => contentIds.push(item.content_id)))
+
+    for (const call of (fetchJson as jest.Mock).mock.calls) {
+        expect(call[0]).toBe('/api/v1/courses/0/blueprint_templates/default/restrict_item')
+    }
+    expect(fetchJson).toHaveBeenCalledTimes(itemCount * moduleCount);
+    fetchMock.mockClear();
+})
+
+async function mockBpResponse(mockRequest: Request, numberToMock = 1) {
+    const dummyBpData: ICourseData = {...mockCourseData, blueprint: true};
+    const [_, requestCode] = mockRequest.url.match(/=[^=]*(\w{4}\d{3})/i) || [];
+    const outCourseData: ICourseData[] = [...range(1, numberToMock)].map((number) => ({
+        ...dummyBpData, name: `BP_${requestCode}${number > 1 ? number : ''}`,
+        course_code: `BP_${requestCode}${number > 1 ? number : ''}`
+    }))
+    return JSON.stringify(outCourseData);
+}
+
+
+import {ITermData, Term} from "@/term/Term";
+
+import apiWriteConfig from "@/fetch/apiWriteConfig";
+import {IBlueprintCourse} from "@canvas/course/IBlueprintCourse";
+import {getSections} from "@canvas/course/getSections";
+import {getTermNameFromSections} from "@canvas/course/getTermNameFromSections";
+import {retireBlueprint} from "@canvas/course/retireBlueprint";
+import {NotABlueprintError} from "@canvas/course/notABlueprintError";
+
+
+describe("genBlueprintsForCode", () => {
+    const mockCourseDataGenerator = mockAsyncGen([]);
+    const courseCode = "BP_TEST123";
+    const accountIds = [1, 2, 3];
+    const config: ICanvasCallConfig<GetCoursesFromAccountOptions> = {queryParams: {search_term: "x"}}; // replace with actual config type
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    const consoleWarnSpy = jest.spyOn(console, 'warn');
+
+
+
+    it("should return null for invalid course code", async () => {
+        (getCourseDataGenerator as jest.Mock).mockReturnValue(mockCourseDataGenerator);
+        const courseCode = 'BP_ST123'
+        const result = genBlueprintDataForCode("BP_ST123", accountIds);
+        expect(result).toBeNull();
+        expect(consoleWarnSpy).toHaveBeenCalledWith(`Code ${courseCode} invalid`);
+    });
+
+    it("should generate blueprints for a valid course code", async () => {
+        (fetchGetConfig as jest.Mock).mockReturnValue({blueprint: true});
+        (getCourseDataGenerator as jest.Mock).mockReturnValue(mockCourseDataGenerator);
+        const result = genBlueprintDataForCode(courseCode, accountIds, config.queryParams);
+        expect(fetchGetConfig).toHaveBeenCalled();
+
+        expect(result).toBe(mockCourseDataGenerator);
+        expect(getCourseDataGenerator).toHaveBeenCalledWith(
+            baseCourseCode(courseCode),
+            accountIds,
+            undefined,
+            {blueprint: true}
+        );
+        expect(fetchGetConfig).toHaveBeenCalledWith({blueprint: true, include: ['concluded']}, config);
+    });
+});

package/src/course/__tests__/changeStartDate.test.ts

@@ -0,0 +1,180 @@
+import {
+    getModuleUnlockStartDate, getNewTermName, getOldUgTermName, getStartDateAssignments, MalformedSyllabusError,
+    NoAssignmentsWithDueDatesError, NoOverviewModuleFoundError,
+    sortAssignmentsByDueDate, syllabusHeaderName,
+    updatedDateSyllabusHtml
+} from '../changeStartDate'
+import {Temporal} from "temporal-polyfill";
+import {mockAssignmentData} from "@canvas/content/__mocks__/mockContentData";
+import {range} from "@canvas/canvasUtils";
+import mockModuleData from "@canvas/course/__mocks__/mockModuleData";
+import {Assignment} from "@canvas/content/assignments/Assignment";
+const baseSyllabus = jest.requireActual('@canvas/course/__mocks__/syllabus.gallant.html')
+const gradSyllabus = jest.requireActual('@canvas/course/__mocks__/syllabus.grad.html')
+
+describe('Syllabus date changes', () => {
+
+    test('Changing date works for grad courses', () => {
+        const now = Temporal.Now.plainDateISO();
+        const syllabus = gradSyllabus;
+        const newSyllabus = updatedDateSyllabusHtml(syllabus, now);
+        const month = now.toLocaleString('en-US', {month: "2-digit"})
+        const day = now.toLocaleString('en-US', {day: "2-digit"})
+        const year = now.toLocaleString('en-US', {year: "2-digit"})
+        expect(newSyllabus.html).toContain(`DE8W${month}.${day}.${year}`)
+    });
+    test('Changing date works for undergrad courses', () => {
+        const now = Temporal.Now.plainDateISO();
+        const syllabus = baseSyllabus
+        const newSyllabus = updatedDateSyllabusHtml(syllabus, now);
+        const month = now.toLocaleString('en-US', {month: "2-digit"})
+        const day = now.toLocaleString('en-US', {day: "2-digit"})
+        const year = now.toLocaleString('en-US', {year: "2-digit"})
+        expect(newSyllabus.html).toContain(`DE5W${month}.${day}.${year}`)
+    })
+
+    test('changing date does not double paragraph tags', () => {
+        const now = Temporal.Now.plainDateISO();
+        const newSyllabus = updatedDateSyllabusHtml(baseSyllabus, now);
+        expect(newSyllabus).not.toContain('<p>&nbsp;</p>')
+        expect(newSyllabus).not.toContain('<p></p>')
+        expect(newSyllabus).not.toContain(/<p>\s*<\/p>/)
+    })
+})
+
+function shuffle<T>(list: T[]) {
+    const source = [...list];
+    const dest: T[] = [];
+    while (source.length > 0) {
+        const index = Math.floor(Math.random() * source.length);
+        dest.push(...source.splice(index, 1))
+    }
+    return dest;
+}
+
+describe('sortAssignmentsByDate', () => {
+    const now = Temporal.Now;
+    const mockAssignments: Assignment[] = shuffle([...range(0, 10)].map(i => {
+        return new Assignment({
+            ...mockAssignmentData,
+            id: i,
+            due_at: now.plainDateTimeISO().add({days: 100 - i}).toString(),
+        }, 0);
+    }));
+
+
+    it('sorts assignment by date', () => {
+
+        const sorted = sortAssignmentsByDueDate(mockAssignments);
+        for (let i = 1; i < sorted.length; i++) {
+            const prev = sorted[i - 1];
+            const current = sorted[i];
+            expect(prev.dueAt?.getTime()).toBeLessThan(current.dueAt!.getTime())
+        }
+    })
+
+    it('sorts non-due-date assignments to the end', () => {
+        const toSort = shuffle([...mockAssignments,
+            new Assignment({...mockAssignmentData, due_at: null}, -98),
+            new Assignment({...mockAssignmentData, due_at: null}, -99)
+        ])
+        const sorted = sortAssignmentsByDueDate(toSort);
+        const dates = sorted.map(value => value.dueAt);
+        expect(dates[sorted.length - 1]).toBeNull();
+        expect(dates[sorted.length - 2]).toBeNull();
+    })
+
+})
+
+describe('getCurrentStartDate', () => {
+    it('returns a temporal plainDate if there\'s a module lock date', () => {
+        const mockModules = [
+            {...mockModuleData, unlock_at: '2022-12-24T00:00:00Z'},
+        ]
+        expect(getModuleUnlockStartDate(mockModules)).toEqual(new Temporal.PlainDate(
+            2022, 12, 24));
+    })
+    it("throws an error if it can't find overview module", () => {
+        expect(() => getModuleUnlockStartDate([])).toThrowError(NoOverviewModuleFoundError)
+    })
+    it("returns null if there's no lock date in the first module", () => {
+        const mockModules = [
+            {...mockModuleData, unlock_at: null}
+        ]
+        expect(getModuleUnlockStartDate(mockModules)).toBeNull()
+    })
+})
+
+describe('getStartDateAssignments', () => {
+    function datesToAssignment([year, month, day]: [string, string, string]) {
+        return new Assignment({
+            ...mockAssignmentData,
+            due_at: `${year}-${month}-${day}T00:00:00Z`
+        }, 0)
+    }
+
+    it('gets the first assignment due and returns the monday of that week', () => {
+        const assignments = ([
+            ['2024', '07', '19'],
+            ['2024', '08', '19'],
+            ['2024', '07', '18'],
+            ['2024', '09', '19'],
+        ] as [string, string, string][]).map(datesToAssignment);
+
+        expect(getStartDateAssignments(assignments)).toEqual(new Temporal.PlainDate(2024, 7, 15))
+    })
+
+    it('throws an error if there are no assignments with due dates', () => {
+        const assignments = ([new Assignment({...mockAssignmentData, due_at: null}, 0)])
+        expect(() => getStartDateAssignments(assignments)).toThrow(NoAssignmentsWithDueDatesError)
+    })
+
+    describe('getNewTermName', () => {
+        const newTermStart = new Temporal.PlainDate(2024, 12, 1);
+        it('throws an error with a bad term name', () => {
+            expect(() => getNewTermName('ABCDEFGX', newTermStart)).toThrow(MalformedSyllabusError)
+        })
+
+        it('returns a new style grad term name from old style grad term name', () => {
+            expect(getNewTermName('DE8W05.07.22', newTermStart)).toEqual('DE8W12.01.24')
+        })
+        it('returns a new style undergrad term name from old style undergrad term name', () => {
+            expect(getNewTermName('DE/HL-22-Dec', newTermStart)).toEqual('DE5W12.01.24')
+        })
+
+    })
+
+    describe('getOldUgTermName', () => {
+        it('returns a legacy old styl ug term name', () => {
+            expect(getOldUgTermName(new Temporal.PlainDate(2024, 12, 24))).toEqual('DE-24-Dec')
+        })
+    })
+})
+
+describe('syllabusHeaderName', () => {
+    function fakeHeader(text: string) {
+        const el = document.createElement('p');
+        el.innerHTML = text;
+        return el
+    }
+
+    it('works', () => {
+        expect(syllabusHeaderName(fakeHeader('<strong>Credits:</strong> 3'))).toEqual('Credits')
+    })
+
+    it('handles multiple strong tags', () => {
+        expect(syllabusHeaderName(fakeHeader('<strong>Course</strong> <strong>Inclusive Dates:</strong>'))).toEqual('Course Inclusive Dates')
+    })
+    it('handles outside the tags colon', () => {
+        expect(syllabusHeaderName(fakeHeader('<strong>Course</strong> <strong>Inclusive Dates</strong>:'))).toEqual('Course Inclusive Dates')
+       expect(syllabusHeaderName(fakeHeader('<strong>Credits</strong>:'))).toEqual('Credits')
+
+    })
+    it('return undefined when : not found', () => {
+        expect(syllabusHeaderName(fakeHeader('<strong>Course</strong> <strong>Inclusive Dates</strong>'))).toBeUndefined();
+
+    })
+
+})
+
+

package/src/course/__tests__/index.test.ts

@@ -0,0 +1,104 @@
+import {formDataify, ICanvasCallConfig, range} from "../../canvasUtils";
+import {createNewCourse, getCourseGenerator, getCourseName, setGradingStandardForCourse} from "../toolbox";
+import {mockCourseData} from "../__mocks__/mockCourseData";
+import assert from "assert";
+import fetchMock from "jest-fetch-mock";
+import {Course} from "../Course";
+
+import {ICourseData} from "@/types";
+import {fetchJson} from "@/fetch/fetchJson";
+
+jest.mock('@/fetch/fetchJson', () => ({
+    fetchJson: jest.fn(),
+}))
+
+
+test('Create new course', async () => {
+    const courseCode = 'DEV_ABC1234';
+    const name = 'DEV_ABC134: Test Course';
+    const accountId = 0;
+
+    const courseData: ICourseData = {...mockCourseData, name, course_code: courseCode};
+    (fetchJson as jest.Mock).mockResolvedValue(courseData)
+    const createdCourse = await createNewCourse(courseCode, accountId, name)
+    expect(createdCourse).toStrictEqual(courseData);
+});
+
+describe('Course Generators', () => {
+
+    fetchMock.enableMocks();
+
+    test('Course generator generates courses', async () => {
+
+        const accountIds = [...range(0, 10)]
+        const courseGenerator = getCourseGenerator(
+            'x',
+            accountIds,
+        );
+
+        for (const enrollment_term_id of accountIds) {
+            const codes = ['TEST000', 'ANIM123', 'CHEM897']
+            const courseDatas: ICourseData[] = codes.map(course_code => {
+                return {
+                    ...mockCourseData,
+                    enrollment_term_id,
+                    course_code,
+                }
+            });
+
+            fetchMock.mockResponseOnce(JSON.stringify(courseDatas));
+            for (const code of codes) {
+                const {done, value: course} = await courseGenerator.next();
+                assert(course instanceof Course);
+                expect(done).toBe(false);
+                expect(course.termId).toBe(enrollment_term_id);
+                expect(course.parsedCourseCode).toBe(code);
+            }
+
+        }
+        const {done, value} = await courseGenerator.next();
+        expect(done).toBe(true);
+        expect(value).toBe(undefined);
+    });
+
+
+})
+
+
+
+function testSave<SaveValue>(
+    func:(courseId:number, saveValue:SaveValue, config?:ICanvasCallConfig)=>Promise<ICourseData>,
+    rawDataKey: string,
+    testSubmitValue: SaveValue)
+{
+    const fetchJsonMock = fetchJson as jest.Mock;
+    fetchJsonMock.mockResolvedValue({...mockCourseData, [rawDataKey]: testSubmitValue})
+    const newCourseData = func(0, testSubmitValue);
+    const [url, config] = fetchJsonMock.mock.lastCall as [string, ICanvasCallConfig];
+    const {body} = config.fetchInit as RequestInit & { body: FormData };
+    expect(url).toEqual(`/api/v1/courses/0`)
+    expect([...body.entries()]).toStrictEqual([...formDataify({course: {[rawDataKey]: testSubmitValue}}).entries()])
+
+}
+
+describe('saving data tests', () => {
+    const fetchJsonMock = fetchJson as jest.Mock;
+    it('saves grading standard id', () => testSave(
+        setGradingStandardForCourse,
+        'grading_standard_id', 5)
+    )
+})
+
+
+
+describe('getCourseName', () => {
+    it('works for BP and various term codes', () => {
+        expect(getCourseName({...mockCourseData, name: 'BP_BIOL203: The Biology of Today'})).toEqual('The Biology of Today')
+        expect(getCourseName({...mockCourseData, name: 'DEV_BIOL203: The Biology of Today'})).toEqual('The Biology of Today')
+        expect(getCourseName({...mockCourseData, name: 'DE08W01.01.24_BIOL203: The Biology of Today-01'})).toEqual('The Biology of Today-01')
+    })
+    it('returns full name if there are no colons', () => {
+        expect(getCourseName({...mockCourseData, name: 'The Biology of Today'})).toEqual('The Biology of Today')
+        expect(getCourseName({...mockCourseData, name: 'DEV_BIOL203'})).toEqual('DEV_BIOL203')
+    })
+})