6981b2e7-f844-4ae9-a541-c40442be14be

Build # 6981b2e7-f844-4ae9-a541-c40442be14be

Build Type

circleci

Committed by Sebastian Rettig

Commit Message

fix(tests): tests don't try .txt files

Pull Request Pull Request #833: fix(content type support): fix for Guess the Answer

Run Details

1090 of 1500 branches covered (72.67%)

Branch coverage included in aggregate %.

35 of 44 new or added lines in 4 files covered. (79.55%)

2 existing lines in 2 files now uncovered.

2834 of 3157 relevant lines covered (89.77%)

6809.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.51

/src/adapters/H5PAjaxRouter/H5PAjaxExpressController.ts

import * as express from 'express';
import {
    H5PEditor,
    LibraryName,
    H5pError,
    ContentId,
    IContentMetadata
} from '../..';
import { lookup as mimeLookup } from 'mime-types';
import AjaxSuccessResponse from '../../helpers/AjaxSuccessResponse';
import { Readable } from 'stream';
import { IFileStats, IUser } from '../../types';
import { IRequestWithUser, IRequestWithTranslator } from '../expressTypes';
import SemanticsEnforcer from '../../SemanticsEnforcer';

interface IActionRequest extends IRequestWithUser, IRequestWithTranslator {
    files: {
        file: {
            data: Buffer;
            mimetype: string;
            name: string;
            size: number;
        };
        h5p: {
            data: any;
        };
    };
}

/**
 * The methods in this class can be used to answer AJAX requests that are received by Express routers.
 * You can use all methods independently at your convenience.
 * Note that even though the names getAjax and postAjax imply that only these methods deal with AJAX
 * requests, ALL methods except getDownload deal with AJAX requests. This confusion is caused by the
 * HTTP interface the H5P client uses and we can't change it.
 */
export default class H5PAjaxExpressController {
    constructor(protected h5pEditor: H5PEditor) {}

    /**
     * Get various things through the Ajax endpoint.
     */
    public getAjax = async (
        req: IRequestWithUser,
        res: express.Response
    ): Promise<void> => {
        const { action } = req.query;
        const { majorVersion, minorVersion, machineName, language } = req.query;

        switch (action) {
            case 'content-type-cache':
                const contentTypeCache = await this.h5pEditor.getContentTypeCache(
                    req.user
                );
                res.status(200).json(contentTypeCache);
                break;

            case 'libraries':
                const library = await this.h5pEditor.getLibraryData(
                    machineName?.toString(),
                    majorVersion?.toString(),
                    minorVersion?.toString(),
                    language?.toString()
                );
                res.status(200).json(library);

                break;

            default:
                res.status(400).end();
                break;
        }
    };

    public getContentFile = async (
        req: IRequestWithUser,
        res: express.Response
    ): Promise<void> => {
        const stats = await this.h5pEditor.contentStorage.getFileStats(
            req.params.id,
            req.params.file,
            req.user
        );
        return this.abstractGetContentFile(
            req.params.id,
            req.params.file,
            req.user,
            stats,
            req,
            res
        );
    };

    public getContentParameters = async (
        req: IRequestWithUser,
        res: express.Response
    ): Promise<void> => {
        const content = await this.h5pEditor.getContent(
            req.params.contentId,
            req.user
        );
        res.status(200).json(content);
    };

    public getDownload = async (
        req: IRequestWithUser,
        res: express.Response
    ): Promise<void> => {
        // set filename for the package with .h5p extension
        res.setHeader(
            'Content-disposition',
            `attachment; filename=${req.params.contentId}.h5p`
        );
        await this.h5pEditor.exportContent(req.params.contentId, res, req.user);
    };

    public getLibraryFile = async (
        req: express.Request,
        res: express.Response
    ): Promise<void> => {
        const lib = LibraryName.fromUberName(req.params.uberName);
        const [stats, stream] = await Promise.all([
            this.h5pEditor.libraryManager.getFileStats(lib, req.params.file),
            this.h5pEditor.getLibraryFileStream(lib, req.params.file)
        ]);

        this.pipeStreamToResponse(req.params.file, stream, res, stats.size);
    };

    public getTemporaryContentFile = async (
        req: IRequestWithUser,
        res: express.Response
    ): Promise<void> => {
        const stats = await this.h5pEditor.temporaryStorage.getFileStats(
            req.params.file,
            req.user
        );
        return this.abstractGetContentFile(
            undefined,
            req.params.file,
            req.user,
            stats,
            req,
            res
        );
    };

    /**
     * Post various things through the Ajax endpoint
     * Don't be confused by the fact that many of the requests dealt with here are not
     * really POST requests, but look more like GET requests. This is simply how the H5P
     * client works and we can't change it.
     */
    public postAjax = async (
        req: IActionRequest,
        res: express.Response
    ): Promise<void> => {
        const { action } = req.query;

        let updatedLibCount: number;
        let installedLibCount: number;

        const getLibraryResultText = (
            installed: number,
            updated: number
        ): string =>
            `${
                installed
                    ? req.t
                        ? req.t('installed-libraries', { count: installed })
                        : `Installed ${installed} libraries.`
                    : ''
            } ${
                updated
                    ? req.t
                        ? req.t('updated-libraries', { count: updated })
                        : `Updated ${updated} libraries.`
                    : ''
            }`.trim();

        switch (action) {
            case 'libraries':
                const libraryOverview = await this.h5pEditor.getLibraryOverview(
                    req.body.libraries
                );
                res.status(200).json(libraryOverview);
                break;
            case 'translations':
                const translationsResponse = await this.h5pEditor.listLibraryLanguageFiles(
                    req.body.libraries,
                    req.query.language as string
                );
                res.status(200).json(
                    new AjaxSuccessResponse(translationsResponse)
                );
                break;
            case 'files':
                if (!req.body.field) {
                    throw new H5pError(
                        'malformed-request',
                        { error: "'field' property is missing in request" },
                        400
                    );
                }
                let field: any;
                try {
                    field = JSON.parse(req.body.field);
                } catch (e) {
                    throw new H5pError(
                        'malformed-request',
                        {
                            error:
                                "'field' property is malformed (must be in JSON)"
                        },
                        400
                    );
                }
                const uploadFileResponse = await this.h5pEditor.saveContentFile(
                    req.body.contentId === '0'
                        ? req.query.contentId
                        : req.body.contentId,
                    field,
                    req.files.file,
                    req.user
                );
                res.status(200).json(uploadFileResponse);
                break;
            case 'filter':
                if (!req.body.libraryParameters) {
                    throw new H5pError(
                        'malformed-request',
                        { error: 'libraryParameters missing' },
                        400
                    );
                }

                const {
                    library: unfilteredLibrary,
                    params: unfilteredParams,
                    metadata: unfilteredMetadata
                }: {
                    library: string;
                    metadata: IContentMetadata;
                    params: any;
                } = JSON.parse(req.body.libraryParameters);

                if (
                    !unfilteredLibrary ||
                    !unfilteredParams ||
                    !unfilteredMetadata
                ) {
                    throw new H5pError(
                        'malformed-request',
                        { error: 'Property missing in libraryParameters' },
                        400
                    );
                }

                const enforcer = new SemanticsEnforcer(
                    this.h5pEditor.libraryManager
                );

                await enforcer.enforceSemanticStructure(
                    unfilteredParams,
                    LibraryName.fromUberName(unfilteredLibrary, {
                        useWhitespace: true
                    })
                );

                res.status(200).json(
                    new AjaxSuccessResponse({
                        library: unfilteredLibrary,
                        metadata: unfilteredMetadata,
                        params: unfilteredParams
                    })
                );
                break;
            case 'library-install':
                if (!req.query || !req.query.id || !req.user) {
                    throw new H5pError(
                        'malformed-request',
                        { error: 'Request Parameters incorrect.' },
                        400
                    );
                }
                const installedLibs = await this.h5pEditor.installLibraryFromHub(
                    req.query.id as string,
                    req.user
                );
                updatedLibCount = installedLibs.filter(
                    (l) => l.type === 'patch'
                ).length;
                installedLibCount = installedLibs.filter(
                    (l) => l.type === 'new'
                ).length;

                const contentTypeCache = await this.h5pEditor.getContentTypeCache(
                    req.user
                );
                res.status(200).json(
                    new AjaxSuccessResponse(
                        contentTypeCache,
                        installedLibCount + updatedLibCount > 0
                            ? getLibraryResultText(
                                  installedLibCount,
                                  updatedLibCount
                              )
                            : undefined
                    )
                );
                break;
            case 'library-upload':
                const {
                    installedLibraries,
                    metadata,
                    parameters
                } = await this.h5pEditor.uploadPackage(
                    req.files.h5p.data,
                    req.user
                );
                updatedLibCount = installedLibraries.filter(
                    (l) => l.type === 'patch'
                ).length;
                installedLibCount = installedLibraries.filter(
                    (l) => l.type === 'new'
                ).length;

                const contentTypes = await this.h5pEditor.getContentTypeCache(
                    req.user
                );
                res.status(200).json(
                    new AjaxSuccessResponse(
                        {
                            content: parameters,
                            contentTypes,
                            h5p: metadata
                        },
                        installedLibCount + updatedLibCount > 0
                            ? getLibraryResultText(
                                  installedLibCount,
                                  updatedLibCount
                              )
                            : undefined
                    )
                );
                break;
            default:
                res.status(500).end('NOT IMPLEMENTED');
                break;
        }
    };

    /**
     * Unified handling of range requests for getContentFile and
     * getTemporaryContentFile.
     * @param contentId (optional) the contentId, can be undefined if a
     * temporary file is requested
     */
    private async abstractGetContentFile(
        contentId: ContentId,
        file: string,
        user: IUser,
        stats: IFileStats,
        req: express.Request,
        res: express.Response
    ): Promise<void> {
        const range = req.range(stats.size);
        let start: number;
        let end: number;
        if (range) {
            if (range === -2) {
                throw new H5pError('malformed-request', {}, 400);
            }
            if (range === -1) {
                throw new H5pError('unsatisfiable-range', {}, 416);
            }
            if (range.length > 1) {
                throw new H5pError('multipart-ranges-unsupported', {}, 400);
            }
            start = range[0].start;
            end = range[0].end;
        }

        const stream = await this.h5pEditor.getContentFileStream(
            contentId,
            file,
            user,
            start,
            end
        );
        if (range) {
            this.pipeStreamToPartialResponse(
                req.params.file,
                stream,
                res,
                stats.size,
                start,
                end
            );
        } else {
            this.pipeStreamToResponse(req.params.file, stream, res, stats.size);
        }
    }

    private pipeStreamToPartialResponse = (
        filename: string,
        readStream: Readable,
        response: express.Response,
        totalLength: number,
        start: number,
        end: number
    ) => {
        const contentType = mimeLookup(filename) || 'application/octet-stream';

        response.writeHead(206, {
            'Content-Type': contentType,
            'Content-Length': end - start + 1,
            'Content-Range': `bytes ${start}-${end}/${totalLength}`
        });

        readStream.on('error', (err) => {
            response.status(404).end();
        });
        readStream.pipe(response);
    };

    private pipeStreamToResponse = (
        filename: string,
        readStream: Readable,
        response: express.Response,
        contentLength?: number
    ) => {
        const contentType = mimeLookup(filename) || 'application/octet-stream';
        if (contentLength) {
            response.writeHead(200, {
                'Content-Type': contentType,
                'Content-Length': contentLength,
                'Accept-Ranges': 'bytes'
            });
        } else {
            response.type(contentType);
        }
        readStream.on('error', (err) => {
            response.status(404).end();
        });
        readStream.pipe(response);
    };
}

1	import * as express from 'express';
2	import {	2✔
3	H5PEditor,
4	LibraryName,
5	H5pError,
6	ContentId,
7	IContentMetadata
8	} from '../..';
9	import { lookup as mimeLookup } from 'mime-types';	2✔
10	import AjaxSuccessResponse from '../../helpers/AjaxSuccessResponse';	2✔
11	import { Readable } from 'stream';
12	import { IFileStats, IUser } from '../../types';
13	import { IRequestWithUser, IRequestWithTranslator } from '../expressTypes';
14	import SemanticsEnforcer from '../../SemanticsEnforcer';	2✔
15
16	interface IActionRequest extends IRequestWithUser, IRequestWithTranslator {
17	files: {
18	file: {
19	data: Buffer;
20	mimetype: string;
21	name: string;
22	size: number;
23	};
24	h5p: {
25	data: any;
26	};
27	};
28	}
29
30	/**
31	* The methods in this class can be used to answer AJAX requests that are received by Express routers.
32	* You can use all methods independently at your convenience.
33	* Note that even though the names getAjax and postAjax imply that only these methods deal with AJAX
34	* requests, ALL methods except getDownload deal with AJAX requests. This confusion is caused by the
35	* HTTP interface the H5P client uses and we can't change it.
36	*/
37	export default class H5PAjaxExpressController {	2✔
38	constructor(protected h5pEditor: H5PEditor) {}	18✔
39
40	/**
41	* Get various things through the Ajax endpoint.
42	*/
43	public getAjax = async (	18✔
44	req: IRequestWithUser,
45	res: express.Response	2✔
46	): Promise<void> => {
47	const { action } = req.query;	2✔
48	const { majorVersion, minorVersion, machineName, language } = req.query;	2✔
49
50	switch (action) {	2✔
51	case 'content-type-cache':	1✔
52	const contentTypeCache = await this.h5pEditor.getContentTypeCache(	1✔
53	req.user
54	);
55	res.status(200).json(contentTypeCache);	1✔
56	break;	1✔
57
58	case 'libraries':	1✔
59	const library = await this.h5pEditor.getLibraryData(	1✔
60	machineName?.toString(),	3!
61	majorVersion?.toString(),	3!
62	minorVersion?.toString(),	3!
63	language?.toString()	3!
64	);
65	res.status(200).json(library);	1✔
66
67	break;	1✔
68
69	default:
70	res.status(400).end();	×
71	break;	×
72	}
73	};
74
75	public getContentFile = async (	18✔
76	req: IRequestWithUser,
77	res: express.Response	1✔
78	): Promise<void> => {
79	const stats = await this.h5pEditor.contentStorage.getFileStats(	1✔
80	req.params.id,
81	req.params.file,
82	req.user
83	);
84	return this.abstractGetContentFile(	1✔
85	req.params.id,
86	req.params.file,
87	req.user,
88	stats,
89	req,
90	res
91	);
92	};
93
94	public getContentParameters = async (	18✔
95	req: IRequestWithUser,
96	res: express.Response	1✔
97	): Promise<void> => {
98	const content = await this.h5pEditor.getContent(	1✔
99	req.params.contentId,
100	req.user
101	);
102	res.status(200).json(content);	1✔
103	};
104
105	public getDownload = async (	18✔
106	req: IRequestWithUser,
107	res: express.Response	1✔
108	): Promise<void> => {
109	// set filename for the package with .h5p extension
110	res.setHeader(	1✔
111	'Content-disposition',
112	`attachment; filename=${req.params.contentId}.h5p`
113	);
114	await this.h5pEditor.exportContent(req.params.contentId, res, req.user);	2✔
115	};
116
117	public getLibraryFile = async (	18✔
118	req: express.Request,
119	res: express.Response	4✔
120	): Promise<void> => {
121	const lib = LibraryName.fromUberName(req.params.uberName);	4✔
122	const [stats, stream] = await Promise.all([	3✔
123	this.h5pEditor.libraryManager.getFileStats(lib, req.params.file),
124	this.h5pEditor.getLibraryFileStream(lib, req.params.file)
125	]);
126
127	this.pipeStreamToResponse(req.params.file, stream, res, stats.size);	1✔
128	};
129
130	public getTemporaryContentFile = async (	18✔
131	req: IRequestWithUser,
132	res: express.Response	4✔
133	): Promise<void> => {
134	const stats = await this.h5pEditor.temporaryStorage.getFileStats(	4✔
135	req.params.file,
136	req.user
137	);
138	return this.abstractGetContentFile(	3✔
139	undefined,
140	req.params.file,
141	req.user,
142	stats,
143	req,
144	res
145	);
146	};
147
148	/**
149	* Post various things through the Ajax endpoint
150	* Don't be confused by the fact that many of the requests dealt with here are not
151	* really POST requests, but look more like GET requests. This is simply how the H5P
152	* client works and we can't change it.
153	*/
154	public postAjax = async (	18✔
155	req: IActionRequest,
156	res: express.Response	7✔
157	): Promise<void> => {
158	const { action } = req.query;	7✔
159
160	let updatedLibCount: number;
161	let installedLibCount: number;
162
163	const getLibraryResultText = (	7✔
164	installed: number,
165	updated: number
166	): string =>
167	`${	2✔
168	installed
169	? req.t	2!
170	? req.t('installed-libraries', { count: installed })	2!
171	: `Installed ${installed} libraries.`
172	: ''
173	} ${
174	updated
175	? req.t	2!
176	? req.t('updated-libraries', { count: updated })	×
177	: `Updated ${updated} libraries.`
178	: ''
179	}`.trim();
180
181	switch (action) {	7✔
182	case 'libraries':	1!
183	const libraryOverview = await this.h5pEditor.getLibraryOverview(	1✔
184	req.body.libraries
185	);
186	res.status(200).json(libraryOverview);	1✔
187	break;	1✔
188	case 'translations':	1✔
189	const translationsResponse = await this.h5pEditor.listLibraryLanguageFiles(	1✔
190	req.body.libraries,
191	req.query.language as string
192	);
193	res.status(200).json(	1✔
194	new AjaxSuccessResponse(translationsResponse)
195	);
196	break;	1✔
197	case 'files':	2✔
198	if (!req.body.field) {	2!
199	throw new H5pError(	×
200	'malformed-request',
201	{ error: "'field' property is missing in request" },
202	400
203	);
204	}
205	let field: any;	2✔
206	try {	2✔
207	field = JSON.parse(req.body.field);	2✔
208	} catch (e) {
209	throw new H5pError(	×
210	'malformed-request',
211	{
212	error:
213	"'field' property is malformed (must be in JSON)"
214	},
215	400
216	);
217	}
218	const uploadFileResponse = await this.h5pEditor.saveContentFile(	2✔
219	req.body.contentId === '0'
220	? req.query.contentId	2!
221	: req.body.contentId,
222	field,
223	req.files.file,
224	req.user
225	);
226	res.status(200).json(uploadFileResponse);	2✔
227	break;	2✔
228	case 'filter':	×
229	if (!req.body.libraryParameters) {	×
230	throw new H5pError(	×
231	'malformed-request',
232	{ error: 'libraryParameters missing' },
233	400
234	);
235	}
236
UNCOV 237	const {	×
238	library: unfilteredLibrary,
239	params: unfilteredParams,
240	metadata: unfilteredMetadata
241	}: {
242	library: string;
243	metadata: IContentMetadata;
244	params: any;
245	} = JSON.parse(req.body.libraryParameters);
246
247	if (	×
248	!unfilteredLibrary \|\|	×
249	!unfilteredParams \|\|
250	!unfilteredMetadata
251	) {
252	throw new H5pError(	×
253	'malformed-request',
254	{ error: 'Property missing in libraryParameters' },
255	400
256	);
257	}
258
NEW 259	const enforcer = new SemanticsEnforcer(	×
260	this.h5pEditor.libraryManager
261	);
262
NEW 263	await enforcer.enforceSemanticStructure(	×
264	unfilteredParams,
265	LibraryName.fromUberName(unfilteredLibrary, {
266	useWhitespace: true
267	})
268	);
269
270	res.status(200).json(	×
271	new AjaxSuccessResponse({
272	library: unfilteredLibrary,
273	metadata: unfilteredMetadata,
274	params: unfilteredParams
275	})
276	);
277	break;	×
278	case 'library-install':	×
279	if (!req.query \|\| !req.query.id \|\| !req.user) {	×
280	throw new H5pError(	×
281	'malformed-request',
282	{ error: 'Request Parameters incorrect.' },
283	400
284	);
285	}
286	const installedLibs = await this.h5pEditor.installLibraryFromHub(	×
287	req.query.id as string,
288	req.user
289	);
290	updatedLibCount = installedLibs.filter(	×
291	(l) => l.type === 'patch'	×
292	).length;
293	installedLibCount = installedLibs.filter(	×
294	(l) => l.type === 'new'	×
295	).length;
296
297	const contentTypeCache = await this.h5pEditor.getContentTypeCache(	×
298	req.user
299	);
300	res.status(200).json(	×
301	new AjaxSuccessResponse(
302	contentTypeCache,
303	installedLibCount + updatedLibCount > 0
304	? getLibraryResultText(	×
305	installedLibCount,
306	updatedLibCount
307	)
308	: undefined
309	)
310	);
311	break;	×
312	case 'library-upload':	3✔
313	const {	3✔
314	installedLibraries,
315	metadata,
316	parameters
317	} = await this.h5pEditor.uploadPackage(	3✔
318	req.files.h5p.data,
319	req.user
320	);
321	updatedLibCount = installedLibraries.filter(	2✔
322	(l) => l.type === 'patch'	2✔
323	).length;
324	installedLibCount = installedLibraries.filter(	2✔
325	(l) => l.type === 'new'	2✔
326	).length;
327
328	const contentTypes = await this.h5pEditor.getContentTypeCache(	2✔
329	req.user
330	);
331	res.status(200).json(	2✔
332	new AjaxSuccessResponse(
333	{
334	content: parameters,
335	contentTypes,
336	h5p: metadata
337	},
338	installedLibCount + updatedLibCount > 0
339	? getLibraryResultText(	2!
340	installedLibCount,
341	updatedLibCount
342	)
343	: undefined
344	)
345	);
346	break;	2✔
347	default:
348	res.status(500).end('NOT IMPLEMENTED');	×
349	break;	×
350	}
351	};
352
353	/**
354	* Unified handling of range requests for getContentFile and
355	* getTemporaryContentFile.
356	* @param contentId (optional) the contentId, can be undefined if a
357	* temporary file is requested
358	*/
359	private async abstractGetContentFile(	2✔
360	contentId: ContentId,
361	file: string,
362	user: IUser,
363	stats: IFileStats,
364	req: express.Request,
365	res: express.Response
366	): Promise<void> {
367	const range = req.range(stats.size);	4✔
368	let start: number;
369	let end: number;
370	if (range) {	4!
371	if (range === -2) {	×
372	throw new H5pError('malformed-request', {}, 400);	×
373	}
374	if (range === -1) {	×
375	throw new H5pError('unsatisfiable-range', {}, 416);	×
376	}
377	if (range.length > 1) {	×
378	throw new H5pError('multipart-ranges-unsupported', {}, 400);	×
379	}
380	start = range[0].start;	×
381	end = range[0].end;	×
382	}
383
384	const stream = await this.h5pEditor.getContentFileStream(	4✔
385	contentId,
386	file,
387	user,
388	start,
389	end
390	);
391	if (range) {	4!
392	this.pipeStreamToPartialResponse(	×
393	req.params.file,
394	stream,
395	res,
396	stats.size,
397	start,
398	end
399	);
400	} else {
401	this.pipeStreamToResponse(req.params.file, stream, res, stats.size);	4✔
402	}
403	}
404
405	private pipeStreamToPartialResponse = (	18✔
406	filename: string,
407	readStream: Readable,
408	response: express.Response,
409	totalLength: number,
410	start: number,
411	end: number
412	) => {
413	const contentType = mimeLookup(filename) \|\| 'application/octet-stream';	×
414
415	response.writeHead(206, {	×
416	'Content-Type': contentType,
417	'Content-Length': end - start + 1,
418	'Content-Range': `bytes ${start}-${end}/${totalLength}`
419	});
420
421	readStream.on('error', (err) => {	×
422	response.status(404).end();	×
423	});
424	readStream.pipe(response);	×
425	};
426
427	private pipeStreamToResponse = (	18✔
428	filename: string,
429	readStream: Readable,
430	response: express.Response,
431	contentLength?: number
432	) => {
433	const contentType = mimeLookup(filename) \|\| 'application/octet-stream';	5!
434	if (contentLength) {	5!
435	response.writeHead(200, {	5✔
436	'Content-Type': contentType,
437	'Content-Length': contentLength,
438	'Accept-Ranges': 'bytes'
439	});
440	} else {
441	response.type(contentType);	×
442	}
443	readStream.on('error', (err) => {	5✔
444	response.status(404).end();	×
445	});
446	readStream.pipe(response);	5✔
447	};
448	}	2✔

Lumieducation / H5P-Nodejs-library / 6981b2e7-f844-4ae9-a541-c40442be14be

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous