e6b26a94-5758-4fba-8d4d-775ed6093fb5

Build # e6b26a94-5758-4fba-8d4d-775ed6093fb5

Build Type

circleci

Committed by Sebastian Rettig

Commit Message

feat(xss): improved tests and fixes

Pull Request Pull Request #882: feat(security): text in content is filtered on the server

Run Details

1147 of 1569 branches covered (73.1%)

Branch coverage included in aggregate %.

54 of 58 new or added lines in 1 file covered. (93.1%)

41 existing lines in 3 files now uncovered.

2901 of 3229 relevant lines covered (89.84%)

6704.38 hits per line

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

85.39

/src/DependencyGetter.ts

import LibraryName from './LibraryName';
import { ILibraryName, ILibraryStorage } from './types';

import Logger from './helpers/Logger';
const log = new Logger('DependencyGetter');
/**
 * Gets the libraries required to run a specific library.
 * Uses LibraryManager to get metadata for libraries.
 */
export default class DependencyGetter {
    constructor(private libraryStorage: ILibraryStorage) {
        log.info(`initialize`);
    }

    /**
     * Gets all dependent libraries of the libraries in the list.
     * @param libraries the libraries whose dependencies should be retrieved
     * @param dynamic include dependencies that are part of the dynamicDependencies property or used in the content
     * @param editor include dependencies that are listed in editorDependencies
     * @param preloaded include regular dependencies that are included in preloadedDependencies
     * @param doNotAdd libraries in this list will not be added to the dependency list
     * @returns a list of libraries
     */
    public async getDependentLibraries(
        libraries: ILibraryName[],
        {
            dynamic = false,
            editor = false,
            preloaded = false
        }: { dynamic?: boolean; editor?: boolean; preloaded?: boolean },
        doNotAdd?: ILibraryName[]
    ): Promise<ILibraryName[]> {
        log.info(
            `getting dependent libraries for ${libraries
                .map(
                    (dep) =>
                        `${dep.machineName}-${dep.majorVersion}.${dep.minorVersion}`
                )
                .join(', ')}`
        );
        const dependencies = new Set<string>();
        for (const library of libraries) {
            await this.addDependenciesRecursive(
                new LibraryName(
                    library.machineName,
                    library.majorVersion,
                    library.minorVersion
                ),
                { preloaded, editor, dynamic },
                dependencies,
                doNotAdd
            );
        }
        return Array.from(dependencies).map((str) =>
            LibraryName.fromUberName(str)
        );
    }

    /**
     * Recursively walks through all dependencies of a library and adds them to the set libraries.
     * @param library the library that is currently being processed
     * @param libraries the set to add to
     * @returns the set that was added to (same as libraries; can be used to chain the call)
     */
    private async addDependenciesRecursive(
        library: ILibraryName,
        {
            dynamic = false,
            editor = false,
            preloaded = false
        }: { dynamic: boolean; editor: boolean; preloaded: boolean },
        libraries: Set<string>,
        doNotAdd?: ILibraryName[]
    ): Promise<Set<string>> {
        log.debug(`adding dependencies recursively`);
        // we use strings to make equality comparison easier
        if (libraries.has(LibraryName.toUberName(library))) {
            return null;
        }
        let metadata;
        try {
            metadata = await this.libraryStorage.getLibrary(library);
        } catch {
            // We silently ignore missing libraries, as this can happen with
            // 'fake libraries' used by the H5P client (= libraries which are
            // referenced in the parameters, but don't exist)
            return libraries;
        }
        if (!doNotAdd?.some((dna) => LibraryName.equal(dna, library))) {
            libraries.add(LibraryName.toUberName(library));
        }
        if (preloaded && metadata.preloadedDependencies) {
            await this.addDependenciesToSet(
                metadata.preloadedDependencies,
                { preloaded, editor, dynamic },
                libraries
            );
        }
        if (editor && metadata.editorDependencies) {
            await this.addDependenciesToSet(
                metadata.editorDependencies,
                { preloaded, editor, dynamic },
                libraries
            );
        }
        if (dynamic && metadata.dynamicDependencies) {
            await this.addDependenciesToSet(
                metadata.dynamicDependencies,
                { preloaded, editor, dynamic },
                libraries
            );
        }
        if (dynamic) {
            // TODO: recurse through semantic structure of content.json
        }

        return libraries;
    }

    /**
     * Adds all dependencies in the list to the set.
     */
    private async addDependenciesToSet(
        dependencies: ILibraryName[],
        {
            dynamic = false,
            editor = false,
            preloaded = false
        }: { dynamic: boolean; editor: boolean; preloaded: boolean },
        libraries: Set<string>,
        doNotAdd?: LibraryName[]
    ): Promise<void> {
        log.info(`adding dependencies to set`);
        for (const dependency of dependencies) {
            await this.addDependenciesRecursive(
                new LibraryName(
                    dependency.machineName,
                    dependency.majorVersion,
                    dependency.minorVersion
                ),
                { preloaded, editor, dynamic },
                libraries,
                doNotAdd
            );
        }
    }
}

1	import LibraryName from './LibraryName';	24✔
2	import { ILibraryName, ILibraryStorage } from './types';
3
4	import Logger from './helpers/Logger';	24✔
5	const log = new Logger('DependencyGetter');	24✔
6	/**
7	* Gets the libraries required to run a specific library.
8	* Uses LibraryManager to get metadata for libraries.
9	*/
10	export default class DependencyGetter {	24✔
11	constructor(private libraryStorage: ILibraryStorage) {	154✔
12	log.info(`initialize`);	154✔
13	}
14
15	/**
16	* Gets all dependent libraries of the libraries in the list.
17	* @param libraries the libraries whose dependencies should be retrieved
18	* @param dynamic include dependencies that are part of the dynamicDependencies property or used in the content
19	* @param editor include dependencies that are listed in editorDependencies
20	* @param preloaded include regular dependencies that are included in preloadedDependencies
21	* @param doNotAdd libraries in this list will not be added to the dependency list
22	* @returns a list of libraries
23	*/
24	public async getDependentLibraries(	24✔
25	libraries: ILibraryName[],
26	{
27	dynamic = false,	110!
28	editor = false,	110✔
29	preloaded = false	110!
30	}: { dynamic?: boolean; editor?: boolean; preloaded?: boolean },
31	doNotAdd?: ILibraryName[]
32	): Promise<ILibraryName[]> {
33	log.info(	110✔
34	`getting dependent libraries for ${libraries
35	.map(
36	(dep) =>
37	`${dep.machineName}-${dep.majorVersion}.${dep.minorVersion}`	768✔
38	)
39	.join(', ')}`
40	);
41	const dependencies = new Set<string>();	110✔
42	for (const library of libraries) {	1,646✔
43	await this.addDependenciesRecursive(	1,536✔
44	new LibraryName(
45	library.machineName,
46	library.majorVersion,
47	library.minorVersion
48	),
49	{ preloaded, editor, dynamic },
50	dependencies,
51	doNotAdd
52	);
53	}
54	return Array.from(dependencies).map((str) =>	110✔
55	LibraryName.fromUberName(str)	1,223✔
56	);
57	}
58
59	/**
60	* Recursively walks through all dependencies of a library and adds them to the set libraries.
61	* @param library the library that is currently being processed
62	* @param libraries the set to add to
63	* @returns the set that was added to (same as libraries; can be used to chain the call)
64	*/
65	private async addDependenciesRecursive(	24✔
66	library: ILibraryName,
67	{
68	dynamic = false,	2,613!
69	editor = false,	2,613!
70	preloaded = false	2,613!
71	}: { dynamic: boolean; editor: boolean; preloaded: boolean },
72	libraries: Set<string>,
73	doNotAdd?: ILibraryName[]
74	): Promise<Set<string>> {
75	log.debug(`adding dependencies recursively`);	2,613✔
76	// we use strings to make equality comparison easier
77	if (libraries.has(LibraryName.toUberName(library))) {	2,613✔
78	return null;	1,333✔
79	}
80	let metadata;
81	try {
82	metadata = await this.libraryStorage.getLibrary(library);	1,280✔
83	} catch {
84	// We silently ignore missing libraries, as this can happen with
85	// 'fake libraries' used by the H5P client (= libraries which are
86	// referenced in the parameters, but don't exist)
UNCOV 87	return libraries;	×
88	}
89	if (!doNotAdd?.some((dna) => LibraryName.equal(dna, library))) {	1,280✔
90	libraries.add(LibraryName.toUberName(library));	1,223✔
91	}
92	if (preloaded && metadata.preloadedDependencies) {	1,980✔
93	await this.addDependenciesToSet(	1,160✔
94	metadata.preloadedDependencies,
95	{ preloaded, editor, dynamic },
96	libraries
97	);
98	}
99	if (editor && metadata.editorDependencies) {	2,442✔
100	await this.addDependenciesToSet(	236✔
101	metadata.editorDependencies,
102	{ preloaded, editor, dynamic },
103	libraries
104	);
105	}
106	if (dynamic && metadata.dynamicDependencies) {	2,560!
UNCOV 107	await this.addDependenciesToSet(	×
108	metadata.dynamicDependencies,
109	{ preloaded, editor, dynamic },
110	libraries
111	);
112	}
113	if (dynamic) {	1,280!
114	// TODO: recurse through semantic structure of content.json
115	}
116
117	return libraries;	1,280✔
118	}
119
120	/**
121	* Adds all dependencies in the list to the set.
122	*/
123	private async addDependenciesToSet(	24✔
124	dependencies: ILibraryName[],
125	{
126	dynamic = false,	698!
127	editor = false,	698!
128	preloaded = false	698!
129	}: { dynamic: boolean; editor: boolean; preloaded: boolean },
130	libraries: Set<string>,
131	doNotAdd?: LibraryName[]
132	): Promise<void> {
133	log.info(`adding dependencies to set`);	698✔
134	for (const dependency of dependencies) {	4,388✔
135	await this.addDependenciesRecursive(	3,690✔
136	new LibraryName(
137	dependency.machineName,
138	dependency.majorVersion,
139	dependency.minorVersion
140	),
141	{ preloaded, editor, dynamic },
142	libraries,
143	doNotAdd
144	);
145	}
146	}
147	}	24✔

Lumieducation / H5P-Nodejs-library / e6b26a94-5758-4fba-8d4d-775ed6093fb5

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