10954763988

Committed 20 Sep 2024 07:04AM UTC coverage: 70.407% (-1.0%) from 71.398%

Build # 10954763988

Build Type

Pull #1318

github

Committed by

web-flow

Commit Message

Merge 96fb62b41 into e121a9bbc

Pull Request Pull Request #1318: Dependency updates iteration 3 - upgrade jasmine and schematics

Run Details

910 of 1325 branches covered (68.68%)

Branch coverage included in aggregate %.

71 of 72 new or added lines in 14 files covered. (98.61%)

80 existing lines in 5 files now uncovered.

4731 of 6687 relevant lines covered (70.75%)

85.62 hits per line

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

55.07

/packages/ng-schematics/src/ng-new/index_spec.ts

import { SchematicContext, Tree } from "@angular-devkit/schematics";
import { NodePackageTaskOptions } from "@angular-devkit/schematics/tasks/package-manager/options";
import { RepositoryInitializerTaskOptions } from "@angular-devkit/schematics/tasks/repo-init/options";
import { RunSchematicTaskOptions } from "@angular-devkit/schematics/tasks/run-schematic/options";
import { SchematicTestRunner, UnitTestTree } from "@angular-devkit/schematics/testing";
import { BaseTemplate, GoogleAnalytics, ProjectLibrary, ProjectTemplate, Template } from "@igniteui/cli-core";
import * as path from "path";
import { take } from "rxjs/operators";
import * as AppProjectSchematic from "../app-projects/index";
import { SchematicsPromptSession } from "../prompt/SchematicsPromptSession";

const collectionPath = path.join(__dirname, "../collection.json");

describe("Schematics ng-new", () => {

        beforeAll(() => {
                spyOn(GoogleAnalytics, "post");
        });

        it("works with no name provided", () => {
                const runner = new SchematicTestRunner("schematics", collectionPath);
                const myTree = Tree.empty();
                const workingDirectory = "my-test-project";

                const mockBaseTemplate: BaseTemplate = {
            id: "mock-template-id",
            name: "mock-template",
            description: "A mock template",
            delimiters: {
                content: { start: "{{", end: "}}" },
                path: { start: "[[", end: "]]" }
            },
            dependencies: ["mock-dependency"],
            framework: "angular",
            projectType: "ts",
            hasExtraConfiguration: true,
            templatePaths: ["/path/to/template"],
            generateConfig: jasmine.createSpy().and.returnValue({}),
            getExtraConfiguration: jasmine.createSpy().and.returnValue([]),
            setExtraConfiguration: jasmine.createSpy()
        };

        const mockProjectTemplate: ProjectTemplate = {
            ...mockBaseTemplate,
            installModules: jasmine.createSpy().and.callFake(() => {}),
            upgradeIgniteUIPackages: jasmine.createSpy().and.returnValue(Promise.resolve(true))
        };

                const mockTemplate: Template = {
                        ...mockBaseTemplate,
                        components: ["mock-component"],
                        controlGroup: "mock-group",
                        listInComponentTemplates: true,
                        listInCustomTemplates: true,
                        packages: ["mock-package"],
                        registerInProject: jasmine.createSpy(),
                };

                const mockLibrary: ProjectLibrary = {
                        name: "mock-library",
                        themes: ["mock-theme"],
                        components: [{
                                name: "mock-component",
                                description: "A mock component",
                                group: "mock-group",
                                groupPriority: 1,
                                templates: [mockTemplate]
                        }],
                        projectIds: ["another-mock"],
                        projects: [mockProjectTemplate],
                        templates: [mockTemplate],
                        projectType: "ts",
                        generateTemplateFolderPath: "/path/to/templates",
                        getCustomTemplateNames: jasmine.createSpy().and.returnValue([]),
                        getTemplateByName: jasmine.createSpy().and.returnValue(mockTemplate),
                        getTemplateById: jasmine.createSpy().and.returnValue(mockTemplate),
                        getComponentByName: jasmine.createSpy().and.returnValue({
                                name: "mock-component",
                                description: "A mock component",
                                group: "mock-group",
                                groupPriority: 1,
                                templates: [mockTemplate]
                        }),
                        getComponentGroupNames: jasmine.createSpy().and.returnValue(["mock-group"]),
                        getComponentsByGroup: jasmine.createSpy().and.returnValue([{
                                name: "mock-component",
                                description: "A mock component",
                                group: "mock-group",
                                groupPriority: 1,
                                templates: [mockTemplate]
                        }]),
                        getComponentGroups: jasmine.createSpy().and.returnValue([{
                                name: "mock-group",
                                description: "A mock component group"
                        }]),
                        getCustomTemplates: jasmine.createSpy().and.returnValue([mockTemplate]),
                        getProject: jasmine.createSpy().and.returnValue(mockProjectTemplate),
                        hasProject: jasmine.createSpy().and.returnValue(false),
                        hasTemplate: jasmine.createSpy().and.returnValue(false),
                        registerTemplate: jasmine.createSpy()
                };

                const mockProject: Partial<ProjectTemplate> = {
                        upgradeIgniteUIPackages: () => Promise.resolve(true)
                };
                spyOn(mockProject, "upgradeIgniteUIPackages").and.callThrough();

                const mockSession = {
                        chooseActionLoop: spyOn(SchematicsPromptSession.prototype, "chooseActionLoop")
                                .and.returnValue(Promise.resolve()),
                        getProjectLibraryByType: spyOn(SchematicsPromptSession.prototype, "getProjectLibraryByType")
                                .and.returnValue((Promise.resolve(mockLibrary))),
                        getProjectTemplate: spyOn(SchematicsPromptSession.prototype, "getProjectTemplate")
                                .and.returnValue(Promise.resolve(mockProjectTemplate)),
                        getTheme: spyOn(SchematicsPromptSession.prototype, "getTheme")
                                .and.returnValue(Promise.resolve("custom")),
                        getUserInput: spyOn(SchematicsPromptSession.prototype, "getUserInput")
                                .and.returnValue(Promise.resolve(workingDirectory))
                };

                const userAnswers = new Map<string, any>();
                userAnswers.set("upgradePackages", true);
                Object.defineProperty(SchematicsPromptSession.prototype, "userAnswers", {
                        configurable: true,
                        get: () => userAnswers,
                        set: () => void 0
                });

                spyOn(AppProjectSchematic, "default").and.returnValue((currentTree: Tree, _context: SchematicContext) => {
                        currentTree.create("gitignore", "");
                        return currentTree;
                });

                runner.runSchematic("ng-new", { version: "8.0.3" }, myTree)
                .then((e: UnitTestTree) => {
                        for (const mockFunc of Object.entries(mockSession)) {
                                expect(mockFunc[1]).toHaveBeenCalled();
                        }
                        expect(AppProjectSchematic.default).toHaveBeenCalled();
                        expect(e.files.length).toEqual(1);
                        expect(e.exists(`${workingDirectory}/.gitignore`)).toBeTruthy();
                        const taskOptions = runner.tasks.map(task => task.options);
                        // tslint:disable:object-literal-sort-keys
                        const expectedInstall: NodePackageTaskOptions = {
                                command: "install",
                                quiet: true,
                                workingDirectory,
                                packageName: undefined,
                                packageManager: undefined
                        };
                        const expectedInit: RepositoryInitializerTaskOptions = {
                                workingDirectory,
                                authorEmail: undefined,
                                authorName: undefined,
                                commit: true,
                                message: `Initial commit for project: ${workingDirectory}`
                        };
                        const expectedStart: RunSchematicTaskOptions<any> = {
                                collection: null,
                                name: "start",
                                options: {
                                        directory: "my-test-project"
                                }
                        };
                        expect(taskOptions.length).toBe(3);
                        expect(mockProject.upgradeIgniteUIPackages).toHaveBeenCalled();
                        expect(taskOptions).toContain(jasmine.objectContaining(expectedInstall));
                        expect(taskOptions).toContain(expectedInit);
                        expect(taskOptions).toContain(expectedStart);
                });
        });

        it("works with name provided", () => {
                const runner = new SchematicTestRunner("schematics", collectionPath);
                const myTree = Tree.empty();
                const workingDirectory = "my-test-project";
                const mockProject: Partial<ProjectTemplate> = {
                        upgradeIgniteUIPackages: () => Promise.resolve(true)
                };
                spyOn(mockProject, "upgradeIgniteUIPackages").and.callThrough();

                const userAnswers = new Map<string, any>();
                userAnswers.set("upgradePackages", true);
                spyOnProperty(SchematicsPromptSession.prototype, "userAnswers", "get").and.returnValue(userAnswers);

                spyOn(AppProjectSchematic, "default").and.returnValue((currentTree: Tree, _context: SchematicContext) => {
                        currentTree.create("gitignore", "");
                        return currentTree;
                });

                runner.runSchematic("ng-new", { version: "8.0.3", name: workingDirectory }, myTree)
                .then((e: UnitTestTree) => {
                        expect(AppProjectSchematic.default).toHaveBeenCalled();
                        expect(e.files.length).toEqual(1);
                        expect(e.exists(`${workingDirectory}/.gitignore`)).toBeTruthy();
                        const taskOptions = runner.tasks.map(task => task.options);
                        // tslint:disable:object-literal-sort-keys
                        const expectedInstall: NodePackageTaskOptions = {
                                command: "install",
                                quiet: true,
                                workingDirectory,
                                packageName: undefined,
                                packageManager: undefined
                        };
                        const expectedInit: RepositoryInitializerTaskOptions = {
                                workingDirectory,
                                authorEmail: undefined,
                                authorName: undefined,
                                commit: true,
                                message: `Initial commit for project: ${workingDirectory}`
                        };
                        expect(taskOptions.length).toBe(2);
                        expect(mockProject.upgradeIgniteUIPackages).toHaveBeenCalled();
                        expect(taskOptions).toContain(jasmine.objectContaining(expectedInstall));
                        expect(taskOptions).toContain(expectedInit);
                });
        });
});

1	import { SchematicContext, Tree } from "@angular-devkit/schematics";	1✔
2	import { NodePackageTaskOptions } from "@angular-devkit/schematics/tasks/package-manager/options";
3	import { RepositoryInitializerTaskOptions } from "@angular-devkit/schematics/tasks/repo-init/options";
4	import { RunSchematicTaskOptions } from "@angular-devkit/schematics/tasks/run-schematic/options";
5	import { SchematicTestRunner, UnitTestTree } from "@angular-devkit/schematics/testing";	1✔
6	import { BaseTemplate, GoogleAnalytics, ProjectLibrary, ProjectTemplate, Template } from "@igniteui/cli-core";	1✔
7	import * as path from "path";	1✔
8	import { take } from "rxjs/operators";
9	import * as AppProjectSchematic from "../app-projects/index";	1✔
10	import { SchematicsPromptSession } from "../prompt/SchematicsPromptSession";	1✔
11
12	const collectionPath = path.join(__dirname, "../collection.json");	1✔
13
14	describe("Schematics ng-new", () => {	1✔
15
16	beforeAll(() => {	1✔
17	spyOn(GoogleAnalytics, "post");	1✔
18	});
19
20	it("works with no name provided", () => {	1✔
21	const runner = new SchematicTestRunner("schematics", collectionPath);	1✔
22	const myTree = Tree.empty();	1✔
23	const workingDirectory = "my-test-project";	1✔
24
25	const mockBaseTemplate: BaseTemplate = {	1✔
26	id: "mock-template-id",
27	name: "mock-template",
28	description: "A mock template",
29	delimiters: {
30	content: { start: "{{", end: "}}" },
31	path: { start: "[[", end: "]]" }
32	},
33	dependencies: ["mock-dependency"],
34	framework: "angular",
35	projectType: "ts",
36	hasExtraConfiguration: true,
37	templatePaths: ["/path/to/template"],
38	generateConfig: jasmine.createSpy().and.returnValue({}),
39	getExtraConfiguration: jasmine.createSpy().and.returnValue([]),
40	setExtraConfiguration: jasmine.createSpy()
41	};
42
43	const mockProjectTemplate: ProjectTemplate = {	1✔
44	...mockBaseTemplate,
45	installModules: jasmine.createSpy().and.callFake(() => {}),
46	upgradeIgniteUIPackages: jasmine.createSpy().and.returnValue(Promise.resolve(true))
47	};
48
49	const mockTemplate: Template = {	1✔
50	...mockBaseTemplate,
51	components: ["mock-component"],
52	controlGroup: "mock-group",
53	listInComponentTemplates: true,
54	listInCustomTemplates: true,
55	packages: ["mock-package"],
56	registerInProject: jasmine.createSpy(),
57	};
58
59	const mockLibrary: ProjectLibrary = {	1✔
60	name: "mock-library",
61	themes: ["mock-theme"],
62	components: [{
63	name: "mock-component",
64	description: "A mock component",
65	group: "mock-group",
66	groupPriority: 1,
67	templates: [mockTemplate]
68	}],
69	projectIds: ["another-mock"],
70	projects: [mockProjectTemplate],
71	templates: [mockTemplate],
72	projectType: "ts",
73	generateTemplateFolderPath: "/path/to/templates",
74	getCustomTemplateNames: jasmine.createSpy().and.returnValue([]),
75	getTemplateByName: jasmine.createSpy().and.returnValue(mockTemplate),
76	getTemplateById: jasmine.createSpy().and.returnValue(mockTemplate),
77	getComponentByName: jasmine.createSpy().and.returnValue({
78	name: "mock-component",
79	description: "A mock component",
80	group: "mock-group",
81	groupPriority: 1,
82	templates: [mockTemplate]
83	}),
84	getComponentGroupNames: jasmine.createSpy().and.returnValue(["mock-group"]),
85	getComponentsByGroup: jasmine.createSpy().and.returnValue([{
86	name: "mock-component",
87	description: "A mock component",
88	group: "mock-group",
89	groupPriority: 1,
90	templates: [mockTemplate]
91	}]),
92	getComponentGroups: jasmine.createSpy().and.returnValue([{
93	name: "mock-group",
94	description: "A mock component group"
95	}]),
96	getCustomTemplates: jasmine.createSpy().and.returnValue([mockTemplate]),
97	getProject: jasmine.createSpy().and.returnValue(mockProjectTemplate),
98	hasProject: jasmine.createSpy().and.returnValue(false),
99	hasTemplate: jasmine.createSpy().and.returnValue(false),
100	registerTemplate: jasmine.createSpy()
101	};
102
103	const mockProject: Partial<ProjectTemplate> = {	1✔
UNCOV 104	upgradeIgniteUIPackages: () => Promise.resolve(true)	×
105	};
106	spyOn(mockProject, "upgradeIgniteUIPackages").and.callThrough();	1✔
107
108	const mockSession = {	1✔
109	chooseActionLoop: spyOn(SchematicsPromptSession.prototype, "chooseActionLoop")
110	.and.returnValue(Promise.resolve()),
111	getProjectLibraryByType: spyOn(SchematicsPromptSession.prototype, "getProjectLibraryByType")
112	.and.returnValue((Promise.resolve(mockLibrary))),
113	getProjectTemplate: spyOn(SchematicsPromptSession.prototype, "getProjectTemplate")
114	.and.returnValue(Promise.resolve(mockProjectTemplate)),
115	getTheme: spyOn(SchematicsPromptSession.prototype, "getTheme")
116	.and.returnValue(Promise.resolve("custom")),
117	getUserInput: spyOn(SchematicsPromptSession.prototype, "getUserInput")
118	.and.returnValue(Promise.resolve(workingDirectory))
119	};
120
121	const userAnswers = new Map<string, any>();	1✔
122	userAnswers.set("upgradePackages", true);	1✔
123	Object.defineProperty(SchematicsPromptSession.prototype, "userAnswers", {	1✔
124	configurable: true,
125	get: () => userAnswers,	2✔
UNCOV 126	set: () => void 0	×
127	});
128
129	spyOn(AppProjectSchematic, "default").and.returnValue((currentTree: Tree, _context: SchematicContext) => {	1✔
UNCOV 130	currentTree.create("gitignore", "");	×
UNCOV 131	return currentTree;	×
132	});
133
134	runner.runSchematic("ng-new", { version: "8.0.3" }, myTree)	1✔
135	.then((e: UnitTestTree) => {
UNCOV 136	for (const mockFunc of Object.entries(mockSession)) {	×
UNCOV 137	expect(mockFunc[1]).toHaveBeenCalled();	×
138	}
UNCOV 139	expect(AppProjectSchematic.default).toHaveBeenCalled();	×
UNCOV 140	expect(e.files.length).toEqual(1);	×
UNCOV 141	expect(e.exists(`${workingDirectory}/.gitignore`)).toBeTruthy();	×
UNCOV 142	const taskOptions = runner.tasks.map(task => task.options);	×
143	// tslint:disable:object-literal-sort-keys
UNCOV 144	const expectedInstall: NodePackageTaskOptions = {	×
145	command: "install",
146	quiet: true,
147	workingDirectory,
148	packageName: undefined,
149	packageManager: undefined
150	};
UNCOV 151	const expectedInit: RepositoryInitializerTaskOptions = {	×
152	workingDirectory,
153	authorEmail: undefined,
154	authorName: undefined,
155	commit: true,
156	message: `Initial commit for project: ${workingDirectory}`
157	};
UNCOV 158	const expectedStart: RunSchematicTaskOptions<any> = {	×
159	collection: null,
160	name: "start",
161	options: {
162	directory: "my-test-project"
163	}
164	};
UNCOV 165	expect(taskOptions.length).toBe(3);	×
UNCOV 166	expect(mockProject.upgradeIgniteUIPackages).toHaveBeenCalled();	×
UNCOV 167	expect(taskOptions).toContain(jasmine.objectContaining(expectedInstall));	×
UNCOV 168	expect(taskOptions).toContain(expectedInit);	×
UNCOV 169	expect(taskOptions).toContain(expectedStart);	×
170	});
171	});
172
173	it("works with name provided", () => {	1✔
174	const runner = new SchematicTestRunner("schematics", collectionPath);	1✔
175	const myTree = Tree.empty();	1✔
176	const workingDirectory = "my-test-project";	1✔
177	const mockProject: Partial<ProjectTemplate> = {	1✔
UNCOV 178	upgradeIgniteUIPackages: () => Promise.resolve(true)	×
179	};
180	spyOn(mockProject, "upgradeIgniteUIPackages").and.callThrough();	1✔
181
182	const userAnswers = new Map<string, any>();	1✔
183	userAnswers.set("upgradePackages", true);	1✔
184	spyOnProperty(SchematicsPromptSession.prototype, "userAnswers", "get").and.returnValue(userAnswers);	1✔
185
186	spyOn(AppProjectSchematic, "default").and.returnValue((currentTree: Tree, _context: SchematicContext) => {	1✔
UNCOV 187	currentTree.create("gitignore", "");	×
UNCOV 188	return currentTree;	×
189	});
190
191	runner.runSchematic("ng-new", { version: "8.0.3", name: workingDirectory }, myTree)	1✔
192	.then((e: UnitTestTree) => {
UNCOV 193	expect(AppProjectSchematic.default).toHaveBeenCalled();	×
UNCOV 194	expect(e.files.length).toEqual(1);	×
UNCOV 195	expect(e.exists(`${workingDirectory}/.gitignore`)).toBeTruthy();	×
UNCOV 196	const taskOptions = runner.tasks.map(task => task.options);	×
197	// tslint:disable:object-literal-sort-keys
UNCOV 198	const expectedInstall: NodePackageTaskOptions = {	×
199	command: "install",
200	quiet: true,
201	workingDirectory,
202	packageName: undefined,
203	packageManager: undefined
204	};
UNCOV 205	const expectedInit: RepositoryInitializerTaskOptions = {	×
206	workingDirectory,
207	authorEmail: undefined,
208	authorName: undefined,
209	commit: true,
210	message: `Initial commit for project: ${workingDirectory}`
211	};
UNCOV 212	expect(taskOptions.length).toBe(2);	×
UNCOV 213	expect(mockProject.upgradeIgniteUIPackages).toHaveBeenCalled();	×
UNCOV 214	expect(taskOptions).toContain(jasmine.objectContaining(expectedInstall));	×
UNCOV 215	expect(taskOptions).toContain(expectedInit);	×
216	});
217	});
218	});

IgniteUI / igniteui-cli / 10954763988

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