@ueu/ueu-canvas 0.0.2 → 0.0.3

package/src/__tests__/fetch.test.ts

@@ -1,310 +0,0 @@
-import {deepObjectMerge, ICanvasCallConfig, queryStringify, range, renderAsyncGen} from "../canvasUtils";
-import {describe, expect} from "@jest/globals";
-import {CanvasData} from "../canvasDataDefs";
-import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
-import {fetchGetConfig} from "@/fetch/utils";
-import {fetchJson} from "@/fetch/fetchJson";
-import {canvasDataFetchGenFunc} from "@/fetch/canvasDataFetchGenFunc";
-
-global.fetch = jest.fn();
-const fetchMock = fetch as jest.Mock;
-
-describe('renderAsyncGen renders an async generator out', () => {
-    const entries = range(0, 20);
-    it('render async generator', async () => {
-        const asyncGen = async function* () {
-            for (const i of [...entries]) {
-                yield i;
-            }
-        }
-        const entryIterator = range(0, 20);
-        for (const result of await renderAsyncGen(asyncGen())) {
-            expect(result).toEqual(entryIterator.next().value)
-        }
-    })
-})
-
-describe('canvasDataFetchGenFunc', () => {
-    type Goober = {
-        name: string,
-        courseId: number,
-        gooberId: number,
-    } & CanvasData
-    const config: ICanvasCallConfig = {fetchInit: {}};
-    const goobers: Goober[] = [...range(0, 10)].map(i => ({name: 'thistle', courseId: i, gooberId: i}));
-
-
-    it('successfully generates urls and results', async () => {
-        const fetchGoobersGen = canvasDataFetchGenFunc<Goober, { courseId: number, gooberId: number }>(({
-                                                                                                            courseId,
-                                                                                                            gooberId
-                                                                                                        }) => `/api/v1/${courseId}/${gooberId}`);
-        for (let i = 0; i < 10; i++) {
-            expect(fetchMock).toBeCalledTimes(i);
-            const expectedFetchResult = [goobers[i]];
-            fetchMock.mockResolvedValue({
-                json: async () => expectedFetchResult
-            })
-            const getGoobers = fetchGoobersGen({courseId: i, gooberId: i * 2}, config);
-            const {value} = await getGoobers.next();
-            expect(fetchMock).toHaveBeenCalledWith(`/api/v1/${i}/${i * 2}`, config.fetchInit)
-            expect(value).toEqual(goobers[i]);
-        }
-    })
-})
-
-describe('fetchJson', () => {
-    const testData = {a: 1, b: 2, c: 3};
-
-    it('rejects relative paths', async () => {
-        await expect(async () => await fetchJson('apple/dumpling/gang')).rejects.toThrow()
-    })
-    it('accepts paths starting with /', async () => {
-        fetchMock.mockResolvedValue({json: async () => testData})
-        expect(await fetchJson('/apple/dumpling/gang')).toEqual(testData)
-    })
-    it('accepts paths starting with http, http, ftp', async () => {
-        fetchMock.mockResolvedValue({json: async () => testData})
-        expect(await fetchJson('http://localhost:8080/apple/dumpling/gang')).toEqual(testData)
-        fetchMock.mockResolvedValue({json: async () => testData})
-        expect(await fetchJson('https://localhost:8080/apple/dumpling/gang')).toEqual(testData)
-        fetchMock.mockResolvedValue({json: async () => testData})
-        expect(await fetchJson('ftp://localhost:8080/apple/dumpling/gang')).toEqual(testData)
-    })
-
-    it('incorporatesQueryParams', async () => {
-        fetchMock.mockReturnValue({json: async () => testData});
-        const fetchInit: RequestInit = {method: 'PUT'};
-        await fetchJson('/url', {
-            queryParams: {
-                query: 'test'
-            },
-            fetchInit,
-        });
-        expect(fetchMock).toHaveBeenCalledWith('/url?query=test', fetchInit)
-
-    })
-})
-
-describe('fetchGetConfig', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should merge the options in', () => {
-        const options = {param1: 'value1'};
-        const baseConfig = {queryParams: {a: '1'}};
-
-        const config = fetchGetConfig<Record<string, any>>(options, baseConfig);
-
-        expect(config).toEqual(deepObjectMerge<Record<string, any>>({queryParams: options}, baseConfig))
-    });
-})
-
-
-describe('getPagedDataGenerator', () => {
-
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should append queryParams to the URL if provided', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockConfig: ICanvasCallConfig = {
-            queryParams: {key1: 'value1', key2: 'value2'},
-        };
-
-        const mockData = [{id: 1}, {id: 2}];
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(mockData),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const urlWithParams = `${mockUrl}?key1=value1&key2=value2`;
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl, mockConfig);
-        await generator.next();
-
-        expect(fetchMock).toHaveBeenCalledWith(urlWithParams, mockConfig.fetchInit);
-    });
-
-    it('should yield data from the response', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockData = [{id: 1}, {id: 2}];
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(mockData),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-
-        expect(result1.value).toEqual({id: 1});
-        expect(result2.value).toEqual({id: 2});
-    });
-
-    it('should handle paginated responses', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockDataPage1 = [{id: 1}, {id: 2}];
-        const mockDataPage2 = [{id: 3}, {id: 4}];
-        const nextLink = '<http://example.com/api/data?page=2>; rel="next"';
-
-        fetchMock
-            .mockResolvedValueOnce({
-                json: jest.fn().mockResolvedValue(mockDataPage1),
-                headers: new Headers({Link: nextLink}),
-                ok: true,
-            } as any)
-            .mockResolvedValueOnce({
-                json: jest.fn().mockResolvedValue(mockDataPage2),
-                headers: new Headers({}),
-                ok: true,
-            } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-        const result3 = await generator.next();
-        const result4 = await generator.next();
-
-        expect([
-            result1,
-            result2,
-            result3,
-            result4,
-        ].map(a => a.value.id)).toEqual(
-            [1, 2, 3, 4]
-        )
-
-    });
-
-    it('should log a warning if the URL contains "undefined"', async () => {
-        const mockUrl = 'http://example.com/api/data/undefined';
-        const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-        const mockData = [{id: 1}];
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(mockData),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-        await generator.next();
-
-        expect(consoleWarnSpy).toHaveBeenCalledWith(mockUrl);
-
-        consoleWarnSpy.mockRestore();
-    });
-
-    it('should return an empty array and log a warning if no data is found', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(null),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-        const result = await generator.next();
-
-        expect(result.value).toEqual([]);
-        expect(consoleWarnSpy).toHaveBeenCalledWith(`no data found for ${mockUrl}`);
-
-        consoleWarnSpy.mockRestore();
-    });
-
-    it('should process non-array object response data and yield values', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockData = {items: [{id: 1}, {id: 2}], otherKey: 'value'};
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(mockData),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-
-        expect(result1.value).toEqual({id: 1});
-        expect(result2.value).toEqual({id: 2});
-    });
-
-    it('should handle nested non-array object response data and yield values', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockData = {items: [{id: 1}, {id: 2}], otherKey: 'value'};
-        fetchMock.mockResolvedValue({
-            json: jest.fn().mockResolvedValue(mockData),
-            headers: new Headers({}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-
-        expect(result1.value).toEqual({id: 1});
-        expect(result2.value).toEqual({id: 2});
-    });
-
-    it('should concatenate previous and current page data if response data is non-array object', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockDataPage1 = [{id: 1}];
-        const mockDataPage2 = {items: [{id: 2}, {id: 3}], otherKey: 'value'};
-        const nextLink = '<http://example.com/api/data?page=2>; rel="next"';
-
-        fetchMock
-            .mockResolvedValueOnce({
-                json: jest.fn().mockResolvedValue(mockDataPage1),
-                headers: new Headers({Link: nextLink}),
-                ok: true,
-            } as any)
-            .mockResolvedValueOnce({
-                json: jest.fn().mockResolvedValue(mockDataPage2),
-                headers: new Headers({}),
-                ok: true,
-            } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-        const result3 = await generator.next();
-
-        expect(result1.value.id).toEqual(1);
-        expect(result2.value.id).toEqual(2);
-        expect(result3.value.id).toEqual(3);
-    });
-
-    it('should stop pagination when no next link is present', async () => {
-        const mockUrl = 'http://example.com/api/data';
-        const mockDataPage1 = [{id: 1}];
-        const noNextLink = '';
-
-        fetchMock.mockResolvedValueOnce({
-            json: jest.fn().mockResolvedValue(mockDataPage1),
-            headers: new Headers({Link: noNextLink}),
-            ok: true,
-        } as any);
-
-        const generator = getPagedDataGenerator<CanvasData>(mockUrl);
-
-        const result1 = await generator.next();
-        const result2 = await generator.next();
-
-        expect(result1.value).toEqual({id: 1});
-        expect(result2.done).toBe(true);
-    });
-
-});

package/src/__tests__/profile.test.ts

@@ -1,19 +0,0 @@
-import {IUserData} from "../canvasDataDefs";
-import {frontPageBio} from "../profile";
-import {mockUserData} from "../__mocks__/mockUserData";
-
-import {IProfile} from "@/types";
-
-describe('frontPageBio', () => {
-        const profile = {
-            user: {...mockUserData, email: "ttestersson@unity.edu"},
-            displayName: "Test Testersson Phd"
-        }
-    it('renders display name properly', () => {
-        expect(frontPageBio(profile)).toContain(profile.displayName);
-    })
-    it('renders email properly', () => {
-        expect(frontPageBio(profile)).toContain(profile.user.email);
-    })
-
-})

package/src/__tests__/rubrics.test.ts

@@ -1,131 +0,0 @@
-
-import {
-    getRubric,
-    rubricApiUrl,
-    getRubricsFetchUrl,
-    rubricsForCourseGen,
-    rubricAssociationUrl, updateRubricAssociation
-} from "../rubrics";
-import {returnMockAsyncGen} from "@/__mocks__/utils";
-import mockRubric, {mockRubricAssociation, mockRubricsForAssignments} from "../__mocks__/mockRubricData";
-
-import {deepObjectMerge, formDataify, renderAsyncGen} from "../canvasUtils";
-import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
-import {fetchJson} from "@/fetch/fetchJson";
-
-
-
-jest.mock('../fetch/fetchJson', () => ({
-    fetchJson: jest.fn(),
-}))
-
-jest.mock('../fetch/getPagedDataGenerator', () => ({
-    getPagedDataGenerator: jest.fn(),
-}))
-
-jest.mock('../canvasUtils', () => ({
-    ...jest.requireActual('../canvasUtils'),
-    formDataify: jest.fn(),
-}));
-
-const pagedDataGenMock = getPagedDataGenerator as jest.Mock;
-const fetchJsonMock = fetchJson as jest.Mock;
-
-describe('rubricsForCourseGen', () => {
-    beforeEach(() => {
-        pagedDataGenMock.mockClear();
-    })
-    it('gets rubrics for a course', async () => {
-        const mockRubrics = [{...mockRubric, id: 1}, {...mockRubric, id: 2}];
-        const config = { fetchInit: {} };
-        pagedDataGenMock.mockImplementation(returnMockAsyncGen(mockRubrics))
-        const rubricGen = rubricsForCourseGen(0, {}, config);
-        expect(await renderAsyncGen(rubricGen)).toEqual(mockRubrics);
-        expect(pagedDataGenMock).toHaveBeenCalledWith(getRubricsFetchUrl(0), config);
-    })
-
-    it('includes associations when needed', async () => {
-        const mockRubrics = mockRubricsForAssignments([0, 1, 2, 3], undefined, {});
-        const mockWithAssociations = mockRubricsForAssignments([0, 1, 2, 3])
-        const mockAssociations = mockWithAssociations.map(rubric => rubric.associations);
-        const config = { fetchInit: {} };
-        (getPagedDataGenerator as jest.Mock).mockImplementation(returnMockAsyncGen(mockRubrics))
-        const rubricGen = rubricsForCourseGen(0, {include: ['associations']}, config);
-        expect(pagedDataGenMock.mock.lastCall).toEqual([
-            getRubricsFetchUrl(0), config
-        ]);
-        const mockRubricIterator = mockRubrics.values();
-        const mockAssocIterator = mockAssociations.values();
-
-        fetchJsonMock.mockImplementation(async(url, config) => {
-            const rubric = mockRubricIterator.next().value;
-            return {...rubric, associations: mockAssocIterator.next().value }
-        })
-
-        expect(await renderAsyncGen(rubricGen)).toEqual(mockWithAssociations);
-    })
-})
-
-describe('getRubric', ()=> {
-    beforeEach(() => {
-        fetchJsonMock.mockClear();
-    })
-
-    it('calls with the correct parameters, returnValue', async() => {
-        const [courseId, rubricId] = [1,2];
-        const expectedUrl = rubricApiUrl(courseId, rubricId);
-        fetchJsonMock.mockResolvedValue(mockRubric);
-        const rubric = await getRubric(courseId, rubricId, {include: ["associations"]}, {fetchInit: {}});
-
-        expect(fetchJsonMock.mock.lastCall).toEqual([
-            expectedUrl,
-            {
-                fetchInit: {},
-                queryParams: { include: ['associations']}
-            }
-        ])
-        expect(rubric).toEqual(mockRubric);
-    })
-})
-
-
-
-describe('rubricAssociationUrl', () => {
-    it('should return the correct URL for given courseId and rubricAssociationId', () => {
-        const courseId = 123;
-        const rubricAssociationId = 456;
-        const expectedUrl = `/api/v1/courses/${courseId}/rubric_associations/${rubricAssociationId}`;
-
-        expect(rubricAssociationUrl(courseId, rubricAssociationId)).toBe(expectedUrl);
-    });
-});
-// Mock dependencies
-
-describe('updateRubricAssociation', () => {
-    const courseId = 123;
-    const rubricAssociationId = 456;
-    const data = { id: 1, rubric_association: {} };
-    const config = { fetchInit: {} };
-
-    beforeEach(() => {
-        fetchJsonMock.mockClear();
-    });
-
-    it('should call fetchJson with the correct URL and merged config', async () => {
-        const mergedConfig = {
-            fetchInit: {
-                method: 'PUT',
-                body: 'someFormData'
-            }
-        };
-
-        (formDataify as jest.Mock).mockReturnValue('someFormData');
-        fetchJsonMock.mockResolvedValue('response');
-
-        const result = await updateRubricAssociation(courseId, rubricAssociationId, data, config);
-
-        expect(formDataify).toHaveBeenCalledWith(data);
-        expect(fetchJson).toHaveBeenCalledWith(`/api/v1/courses/${courseId}/rubric_associations/${rubricAssociationId}`, mergedConfig);
-        expect(result).toBe('response');
-    });
-});

package/src/baseCanvasObject.ts

@@ -1,139 +0,0 @@
-import {CanvasData} from "./canvasDataDefs";
-import assert from "assert";
-import {formDataify, ICanvasCallConfig, renderAsyncGen} from "./canvasUtils";
-import {Course} from "./course/Course";
-import {getPagedData, getPagedDataGenerator} from "./fetch/getPagedDataGenerator";
-import {overrideConfig} from "./fetch/utils";
-import {fetchJson} from "./fetch/fetchJson";
-import {BaseContentItem} from "./content/BaseContentItem";
-
-
-export interface ICanvasObject<CanvasDataType extends CanvasData> {
-    rawData: CanvasDataType,
-    name: string,
-
-    saveData(data: Record<string, any>, config: ICanvasCallConfig | undefined): Promise<Record<string, any>>
-}
-
-/**
- * DEPRECATED
- */
-export class BaseCanvasObject<CanvasDataType extends CanvasData> implements ICanvasObject<CanvasDataType>{
-
-    static idProperty = 'id'; // The field name of the id of the canvas object type
-    static nameProperty: string | null = 'name'; // The field name of the primary name of the canvas object type
-    static contentUrlTemplate: string | null = null; // A templated url to get a single item
-    static allContentUrlTemplate: string | null = null; // A templated url to get all items
-    protected canvasData: CanvasDataType;
-    private _accountId: null | number = null;
-    protected get accountId(): null | number {
-        return this._accountId;
-    }
-    constructor(data: CanvasDataType) {
-        this.canvasData = data || {}; // A dict holding the decoded json representation of the object in Canvas
-    }
-
-    getClass(): typeof BaseContentItem {
-        return this.constructor as typeof BaseContentItem;
-    }
-
-
-    getItem<T>(item: string) {
-        return this.canvasData[item] as T;
-    }
-
-
-    get myClass() {
-        return (<typeof BaseContentItem>this.constructor)
-    }
-
-    get nameKey() {
-        assert(this.myClass.nameProperty);
-        return this.myClass.nameProperty;
-    }
-
-    get rawData(): CanvasDataType {
-        return {...this.canvasData};
-    }
-
-
-    get contentUrlPath(): null | string {
-        const constructor = <typeof BaseCanvasObject>this.constructor;
-
-        assert(typeof this.accountId === 'number');
-        assert(typeof constructor.contentUrlTemplate === 'string');
-        return '/api/v1/' + constructor.contentUrlTemplate
-            .replace('{content_id}', this.id.toString())
-            .replace('{account_id}', this.accountId.toString());
-    }
-
-    get htmlContentUrl() {
-        return `${this.contentUrlPath}`;
-    }
-
-    get data() {
-        return this.canvasData;
-    }
-
-    static async getDataById<T extends CanvasData = CanvasData>(contentId: number, courseId: number | null = null, config: ICanvasCallConfig | null = null): Promise<T> {
-        const url = this.getUrlPathFromIds(contentId, courseId);
-        const response = await fetchJson<T>(url, config);
-        assert(!Array.isArray(response));
-
-        return response;
-    }
-
-    static getUrlPathFromIds(
-        contentId: number,
-        courseId: number | null) {
-        assert(typeof this.contentUrlTemplate === 'string');
-        let url = this.contentUrlTemplate
-            .replace('{content_id}', contentId.toString());
-        if (courseId) url = url.replace('{course_id}', courseId.toString());
-        return url;
-    }
-
-    /**
-     * @param courseId - The course ID to get elements within, if applicable
-     * @param accountId - The account ID to get elements within, if applicable
-     */
-    static getAllUrl(courseId: number | null = null, accountId: number | null = null) {
-        assert(typeof this.allContentUrlTemplate === 'string');
-        let replaced = this.allContentUrlTemplate;
-
-        if (courseId) replaced = replaced.replace('{course_id}', courseId.toString());
-        if (accountId) replaced = replaced.replace('{account_id}', accountId.toString());
-        return replaced;
-    }
-
-    static async getAll(config: ICanvasCallConfig | null = null) {
-        const url = this.getAllUrl();
-        return await renderAsyncGen(getPagedDataGenerator(this.getAllUrl(), config))
-    }
-
-    get id(): number {
-        const id = this.canvasData[(<typeof BaseCanvasObject>this.constructor).idProperty];
-        return parseInt(id);
-    }
-
-    get name() {
-        const nameProperty = this.getClass().nameProperty;
-        if (!nameProperty) return 'NAME PROPERTY NOT SET'
-        return this.getItem<string>(nameProperty);
-    }
-
-    async saveData(data: Record<string, any>, config?: ICanvasCallConfig) {
-        assert(this.contentUrlPath);
-        config = overrideConfig({
-            fetchInit: {
-                method: 'PUT',
-                body: formDataify(data)
-            }
-        }, config);
-
-        let results = await fetchJson(this.contentUrlPath, config) as Partial<CanvasDataType> | Partial<CanvasDataType>[];
-        if(Array.isArray(results)) results = results[0];
-        this.canvasData = {...this.canvasData, ...results};
-        return this.canvasData;
-    }
-}