Activity

1. alan-agius4

   added

   freq1: lowOnly reported by a handful of users who observe it rarelyOnly reported by a handful of users who observe it rarely

   severity3: broken

   type: bug/fix

   area: @angular-devkit/schematics

   on Mar 13, 2020
2. ngbot

   added this to the Backlog milestone on Mar 13, 2020
3. alan-agius4 commented on Mar 13, 2020

   

   alan-agius4

   on Mar 13, 2020

   Collaborator

   More actions

   Hi, I think the problem here is that the destination folder (libs) doesn't exist.
4. catfireparty commented on Mar 16, 2020

   

   catfireparty

   on Mar 16, 2020

   Author

   More actions

   @alan-agius4 If you check the linked repo, running the schematic fully succeeds. The problem is in the missing context when using callRule. It's not clear what that missing context should be in the case of a unit test.

   👍React with 👍1Reacted by Alan Agius
5. tvsbrent commented on Jun 1, 2021

   

   tvsbrent

   on Jun 1, 2021

   More actions

   Having hit the same issue with a rule I'm working on and from digging in, it looks like it is due to the fact that the callRule method in the test runner doesn't create a real Schematic, but just passes in an empty object:

   angular-cli/packages/angular_devkit/schematics/testing/schematic-test-runner.ts

   Line 113 in 37a06a7

   const context = this._engine.createContext({} as Schematic<{}, {}>, parentContext);

   Eventually that empty schematic wends its way here:

   angular-cli/packages/angular_devkit/schematics/src/engine/engine.ts

   Lines 254 to 265 in 37a06a7

   	let context: TypedSchematicContext<CollectionT, SchematicT> = {
   	debug: (parent && parent.debug) || false,
   	engine: this,
   	logger:
   	(parent && parent.logger && parent.logger.createChild(schematic.description.name)) ||
   	new logging.NullLogger(),
   	schematic,
   	strategy:
   	parent && parent.strategy !== undefined ? parent.strategy : this.defaultMergeStrategy,
   	interactive,
   	addTask,
   	};

   Finally, when the file system engine tries to get the path from the schematic, it blows up, as description is not defined:

   angular-cli/packages/angular_devkit/schematics/tools/file-system-engine-host-base.ts

   Line 288 in c1512e4

   const fileDescription = context.schematic.description as { path?: string };

   I think the callRule method would need to provide a way to override or extend that empty schematic object to make this work.
6. clusterb93 commented on Mar 30, 2022

   

   clusterb93

   on Mar 30, 2022

   More actions

   We had the same problem described below and the only solution that we found was to create a CustomSchematicTestRunner that extends the angular-devkit SchematicTestRunner. This custom class exposes a new method that allows to pass a test schematic and context as parameters :

   /**
    * Custom Schematic Test Runner
    */
   
   import { Observable, of as observableOf } from 'rxjs';
   import {SchematicTestRunner} from "@angular-devkit/schematics/testing";
   import {callRule, Rule, Schematic, SchematicContext, Tree} from "@angular-devkit/schematics";
   
   export class CustomSchematicTestRunner extends SchematicTestRunner{
       constructor(collectionName: string, collectionPath: string) {
           super(collectionName, collectionPath);
       }
   
       /**
        * Calls a schematics Rule using an isolated context and the schematics passed in as parameter
        * @param rule
        * @param tree
        * @param schematic
        * @param parentContext
        */
       callSchematicsRule(rule: Rule, tree: Tree, schematic: Schematic<{}, {}>,  parentContext?: Partial<SchematicContext>): Observable<Tree> {
           const context = this.engine.createContext(schematic, parentContext);
           return callRule(rule, observableOf(tree), context);
       }
   }
   

   And in the Rule's unit test the schematic and the context were setted in a beforeEach function as follows :

    schematicTest = {
               description : {
                   name: "Test schematic",
                   path: "src/init"
               }
           };
    testContext = {
               debug: true,
               engine: this,
               logger:
                   new logging.NullLogger(),
               schematicTest,
               strategy: MergeStrategy.Default,
           };
   

   And the final test looks like :

   it('should create a jenkinsfile', async () => {
           const tree = await schematicRunner
               .callSchematicsRule(createJenkinsfile(), appTree, schematicTest as Schematic<{}, {}>, testContext)
               .toPromise();
   
           expect(tree.exists("Jenkinsfile")).toBeTrue();
       });
   

   Hope this technique helps and let you unit test your schematic's Rules waiting for an official fix.