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

79.31

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

import { Tree } from "@angular-devkit/schematics";
import { SchematicTestRunner } from "@angular-devkit/schematics/testing";
import { BaseTemplate, Config, GoogleAnalytics, ProjectConfig, ProjectLibrary, ProjectTemplate, Template } from "@igniteui/cli-core";
import * as path from "path";
import { SchematicsTemplateManager } from "../SchematicsTemplateManager";

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

describe("component",  () => {

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

        it("works", () => {
                const runner = new SchematicTestRunner("schematics", collectionPath);
                const mockInst = {
                        generateConfig: jasmine.createSpy(),
                        packages: [],
                        registerInProject: jasmine.createSpy(),
                        templatePaths: []
                };
                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 mockLib: 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 projLibSpy = spyOn(SchematicsTemplateManager.prototype, "getProjectLibrary");
                projLibSpy.and.returnValue(mockLib);

                const mockConfig = {
                        project: {
                                theme: "Custom"
                        }
                } as unknown as Config;

                const projConfigSpy = spyOn(ProjectConfig, "getConfig");
                projConfigSpy.and.returnValue(mockConfig);

                const tree = runner.runSchematic("component",
                        { name: "my-combo", template: "combo", templateInst: mockInst, skipRoute: false }, Tree.empty());
                tree.then(state => {
                        expect(mockInst.generateConfig).toHaveBeenCalledWith("my-combo", {});
                        expect(mockInst.registerInProject).toHaveBeenCalledWith("", "my-combo", { skipRoute: false, modulePath: undefined });
                        expect(projLibSpy).toHaveBeenCalledWith("angular", "igx-ts");
                        expect(mockLib.hasTemplate).toHaveBeenCalledWith("combo");
                        expect(mockLib.getTemplateById).toHaveBeenCalledWith("combo");
                        expect(state.files).toEqual([]);
                });
        });
});

1	import { Tree } from "@angular-devkit/schematics";	1✔
2	import { SchematicTestRunner } from "@angular-devkit/schematics/testing";	1✔
3	import { BaseTemplate, Config, GoogleAnalytics, ProjectConfig, ProjectLibrary, ProjectTemplate, Template } from "@igniteui/cli-core";	1✔
4	import * as path from "path";	1✔
5	import { SchematicsTemplateManager } from "../SchematicsTemplateManager";	1✔
6
7	const collectionPath = path.join(__dirname, "../collection.json");	1✔
8
9	describe("component", () => {	1✔
10
11	beforeAll(() => {	1✔
12	spyOn(GoogleAnalytics, "post");	1✔
13	});
14
15	it("works", () => {	1✔
16	const runner = new SchematicTestRunner("schematics", collectionPath);	1✔
17	const mockInst = {	1✔
18	generateConfig: jasmine.createSpy(),
19	packages: [],
20	registerInProject: jasmine.createSpy(),
21	templatePaths: []
22	};
23	const mockBaseTemplate: BaseTemplate = {	1✔
24	id: "mock-template-id",
25	name: "mock-template",
26	description: "A mock template",
27	delimiters: {
28	content: { start: "{{", end: "}}" },
29	path: { start: "[[", end: "]]" }
30	},
31	dependencies: ["mock-dependency"],
32	framework: "angular",
33	projectType: "ts",
34	hasExtraConfiguration: true,
35	templatePaths: ["/path/to/template"],
36	generateConfig: jasmine.createSpy().and.returnValue({}),
37	getExtraConfiguration: jasmine.createSpy().and.returnValue([]),
38	setExtraConfiguration: jasmine.createSpy()
39	};
40
41	const mockProjectTemplate: ProjectTemplate = {	1✔
42	...mockBaseTemplate,
43	installModules: jasmine.createSpy().and.callFake(() => {}),
44	upgradeIgniteUIPackages: jasmine.createSpy().and.returnValue(Promise.resolve(true))
45	};
46
47	const mockTemplate: Template = {	1✔
48	...mockBaseTemplate,
49	components: ["mock-component"],
50	controlGroup: "mock-group",
51	listInComponentTemplates: true,
52	listInCustomTemplates: true,
53	packages: ["mock-package"],
54	registerInProject: jasmine.createSpy(),
55	};
56
57	const mockLib: ProjectLibrary = {	1✔
58	name: "mock-library",
59	themes: ["mock-theme"],
60	components: [{
61	name: "mock-component",
62	description: "A mock component",
63	group: "mock-group",
64	groupPriority: 1,
65	templates: [mockTemplate]
66	}],
67	projectIds: ["another-mock"],
68	projects: [mockProjectTemplate],
69	templates: [mockTemplate],
70	projectType: "ts",
71	generateTemplateFolderPath: "/path/to/templates",
72	getCustomTemplateNames: jasmine.createSpy().and.returnValue([]),
73	getTemplateByName: jasmine.createSpy().and.returnValue(mockTemplate),
74	getTemplateById: jasmine.createSpy().and.returnValue(mockTemplate),
75	getComponentByName: jasmine.createSpy().and.returnValue({
76	name: "mock-component",
77	description: "A mock component",
78	group: "mock-group",
79	groupPriority: 1,
80	templates: [mockTemplate]
81	}),
82	getComponentGroupNames: jasmine.createSpy().and.returnValue(["mock-group"]),
83	getComponentsByGroup: jasmine.createSpy().and.returnValue([{
84	name: "mock-component",
85	description: "A mock component",
86	group: "mock-group",
87	groupPriority: 1,
88	templates: [mockTemplate]
89	}]),
90	getComponentGroups: jasmine.createSpy().and.returnValue([{
91	name: "mock-group",
92	description: "A mock component group"
93	}]),
94	getCustomTemplates: jasmine.createSpy().and.returnValue([mockTemplate]),
95	getProject: jasmine.createSpy().and.returnValue(mockProjectTemplate),
96	hasProject: jasmine.createSpy().and.returnValue(false),
97	hasTemplate: jasmine.createSpy().and.returnValue(false),
98	registerTemplate: jasmine.createSpy()
99	};
100
101	const projLibSpy = spyOn(SchematicsTemplateManager.prototype, "getProjectLibrary");	1✔
102	projLibSpy.and.returnValue(mockLib);	1✔
103
104	const mockConfig = {	1✔
105	project: {
106	theme: "Custom"
107	}
108	} as unknown as Config;
109
110	const projConfigSpy = spyOn(ProjectConfig, "getConfig");	1✔
111	projConfigSpy.and.returnValue(mockConfig);	1✔
112
113	const tree = runner.runSchematic("component",	1✔
114	{ name: "my-combo", template: "combo", templateInst: mockInst, skipRoute: false }, Tree.empty());
115	tree.then(state => {	1✔
UNCOV 116	expect(mockInst.generateConfig).toHaveBeenCalledWith("my-combo", {});	×
UNCOV 117	expect(mockInst.registerInProject).toHaveBeenCalledWith("", "my-combo", { skipRoute: false, modulePath: undefined });	×
UNCOV 118	expect(projLibSpy).toHaveBeenCalledWith("angular", "igx-ts");	×
UNCOV 119	expect(mockLib.hasTemplate).toHaveBeenCalledWith("combo");	×
UNCOV 120	expect(mockLib.getTemplateById).toHaveBeenCalledWith("combo");	×
UNCOV 121	expect(state.files).toEqual([]);	×
122	});
123	});
124	});

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