Merge branch 'master' into nalipiev/update-10-schematics

Author: Lipata

projects/igniteui-angular/schematics/ng-add/index.spec.ts

@@ -25,7 +25,14 @@ describe('ng-add schematics', () => {
               polyfills: `${sourceRoot}/polyfills.ts`,
               scripts: []
             }
-          }
+          },
+          test: {
+            options: {
+              main: `${sourceRoot}/test.ts`,
+              polyfills: `${sourceRoot}/polyfills.ts`,
+              scripts: []
+            }
+          },
         }
       }
     }
@@ -46,6 +53,7 @@ describe('ng-add schematics', () => {
     tree.create('/angular.json', JSON.stringify(ngJsonConfig));
     tree.create('/package.json', JSON.stringify(pkgJsonConfig));
     tree.create(`${sourceRoot}/main.ts`, '// test comment');
+    tree.create(`${sourceRoot}/test.ts`, '// test comment');
   });
 
   it('should create the needed files correctly', () => {
@@ -101,7 +109,7 @@ describe('ng-add schematics', () => {
     expect(mainTs).toContain('import \'hammerjs\';');
   });
 
-  it('should not add hammer.js if it exists in angular.json', async () => {
+  it('should not add hammer.js if it exists in angular.json build options', async () => {
     const workspace = getWorkspace(tree) as any;
     const currentProjectName = workspace.defaultProject;
     workspace.projects[currentProjectName].architect.build.options.scripts.push('./node_modules/hammerjs/hammer.min.js');
@@ -112,7 +120,25 @@ describe('ng-add schematics', () => {
     expect(newContent.split('import \'hammerjs\';\n// test comment').length).toEqual(1);
   });
 
+  it('should add hammer.js to the test.ts file', async () => {
+    await runner.runSchematicAsync('ng-add', { normalizeCss: false }, tree).toPromise();
+    const testTs = tree.read(`${sourceRoot}/test.ts`).toString();
+    expect(testTs).toContain('import \'hammerjs\';');
+  });
+
+  it('should not add hammer.js if it exists in angular.json test options', async () => {
+    const workspace = getWorkspace(tree) as any;
+    const currentProjectName = workspace.defaultProject;
+    workspace.projects[currentProjectName].architect.test.options.scripts.push('./node_modules/hammerjs/hammer.min.js');
+    tree.overwrite('angular.json', JSON.stringify(workspace));
+    await runner.runSchematicAsync('ng-add', { normalizeCss: false }, tree).toPromise();
+
+    const testTs = tree.read(`${sourceRoot}/test.ts`).toString();
+    expect(testTs).toMatch('// test comment');
+  });
+
   it('should not add hammer.js if it exists in main.ts', async () => {
+
     const mainTsPath = `${sourceRoot}/main.ts`;
     const content = tree.read(mainTsPath).toString();
     tree.overwrite(mainTsPath, 'import \'hammerjs\';\n' + content);

projects/igniteui-angular/schematics/utils/dependency-handler.ts

@@ -60,16 +60,19 @@ function getTargetedProjectOptions(project: WorkspaceProject<ProjectType>, targe
     throw new SchematicsException(`Cannot determine the project's configuration for: ${target}`);
 }
 
-export function getConfigFile(project: WorkspaceProject<ProjectType>, option: string): string {
-    const buildOptions = getTargetedProjectOptions(project, 'build');
-    if (!buildOptions[option]) {
+export function getConfigFile(project: WorkspaceProject<ProjectType>, option: string, configSection: string = 'build'): string {
+    const options = getTargetedProjectOptions(project, configSection);
+    if (!options) {
+        throw new SchematicsException(`Could not find matching ${configSection} section` +
+            `inside of the workspace config ${project.sourceRoot} `);
+    }
+    if (!options[option]) {
         throw new SchematicsException(`Could not find the project ${option} file inside of the ` +
-            `workspace config (${project.sourceRoot})`);
+            `workspace config ${project.sourceRoot}`);
     }
+    return options[option];
 
-    return buildOptions[option];
 }
-
 export function overwriteJsonFile(tree: Tree, targetFile: string, data: any) {
     tree.overwrite(targetFile, JSON.stringify(data, null, 2) + '\n');
 }
@@ -134,6 +137,20 @@ export function getPropertyFromWorkspace(targetProp: string, workspace: any, cur
     return null;
 }
 
+function addHammerToConfig(project: WorkspaceProject<ProjectType>, tree: Tree, config: string) {
+    const projectOptions = getTargetedProjectOptions(project, config);
+    const tsPath = getConfigFile(project, 'main', config);
+    const hammerImport = 'import \'hammerjs\';\n';
+    const tsContent = tree.read(tsPath).toString();
+    // if there are no elements in the architect[config]options.scripts array that contain hammerjs
+    // and the "main" file does not contain an import with hammerjs
+    if (!projectOptions.scripts.some(el => el.includes('hammerjs')) && !tsContent.includes(hammerImport)) {
+        // import hammerjs in the specified by config main file
+        const mainContents = hammerImport + tsContent;
+        tree.overwrite(tsPath, mainContents);
+    }
+}
+
 function includeDependencies(pkgJson: any, context: SchematicContext, tree: Tree) {
     Object.keys(pkgJson.dependencies).forEach(pkg => {
         const version = pkgJson.dependencies[pkg];
@@ -145,20 +162,10 @@ function includeDependencies(pkgJson: any, context: SchematicContext, tree: Tree
             case 'hammerjs':
                 logIncludingDependency(context, pkg, version);
                 addPackageToPkgJson(tree, pkg, version, entry.target);
-
                 const workspace = getWorkspace(tree);
                 const project = workspace.projects[workspace.defaultProject];
-                const projectOptions = getTargetedProjectOptions(project, 'build');
-                const mainTsPath = getConfigFile(project, 'main');
-                const hammerImport = 'import \'hammerjs\';\n';
-                const mainTsContent = tree.read(mainTsPath).toString();
-                // if there are no elements in the architect.build.options.scripts array that contain hammerjs
-                // and main.ts does not contain an import with hammerjs
-                if (!projectOptions.scripts.some(el => el.includes('hammerjs')) && !mainTsContent.includes(hammerImport)) {
-                    // import hammerjs in the main.ts file
-                    const contents = hammerImport + mainTsContent;
-                    tree.overwrite(mainTsPath, contents);
-                }
+                addHammerToConfig(project, tree, 'build');
+                addHammerToConfig(project, tree, 'test');
                 break;
             default:
                 logIncludingDependency(context, pkg, version);