How to use withDirective method in ng-mocks

Best JavaScript code snippet using ng-mocks

directives.ts

Source:directives.ts

1// tslint:disable:member-ordering2import "reflect-metadata";3import {4  GraphQLSchema,5  graphql,6  GraphQLInputObjectType,7  GraphQLInterfaceType,8  GraphQLObjectType,9} from "graphql";10import {11  Field,12  InputType,13  Resolver,14  Query,15  Arg,16  Directive,17  buildSchema,18  ObjectType,19  Mutation,20  FieldResolver,21  Subscription,22  InterfaceType,23} from "../../src";24import { getMetadataStorage } from "../../src/metadata/getMetadataStorage";25import { SchemaDirectiveVisitor } from "graphql-tools";26import { UpperCaseDirective } from "../helpers/directives/UpperCaseDirective";27import { AppendDirective } from "../helpers/directives/AppendDirective";28import { assertValidDirective } from "../helpers/directives/assertValidDirective";29import { InvalidDirectiveError } from "../../src/errors/InvalidDirectiveError";30describe("Directives", () => {31  let schema: GraphQLSchema;32  describe("Schema", () => {33    beforeAll(async () => {34      getMetadataStorage().clear();35      @InputType()36      class DirectiveOnFieldInput {37        @Field()38        @Directive("@upper")39        append: string;40      }41      @InputType()42      class SubDirectiveOnFieldInput extends DirectiveOnFieldInput {}43      @InputType()44      @Directive("@upper")45      class DirectiveOnClassInput {46        @Field()47        append: string;48      }49      @ObjectType()50      class SampleObjectType {51        @Field()52        @Directive("foo")53        withDirective: string = "withDirective";54        // @Field()55        // @Directive("bar", { baz: "true" })56        // withDirectiveWithArgs: string = "withDirectiveWithArgs";57        @Field()58        @Directive("upper")59        withUpper: string = "withUpper";60        @Field()61        @Directive("@upper")62        withUpperDefinition: string = "withUpperDefinition";63        @Field()64        @Directive("append")65        withAppend: string = "hello";66        @Field()67        @Directive("@append")68        withAppendDefinition: string = "hello";69        @Field()70        @Directive("append")71        @Directive("upper")72        withUpperAndAppend: string = "hello";73        @Field()74        withInput(@Arg("input") input: DirectiveOnFieldInput): string {75          return `hello${input.append}`;76        }77        @Field()78        @Directive("upper")79        withInputUpper(@Arg("input") input: DirectiveOnFieldInput): string {80          return `hello${input.append}`;81        }82        @Field()83        withInputOnClass(@Arg("input") input: DirectiveOnClassInput): string {84          return `hello${input.append}`;85        }86        @Field()87        @Directive("upper")88        withInputUpperOnClass(@Arg("input") input: DirectiveOnClassInput): string {89          return `hello${input.append}`;90        }91      }92      @ObjectType()93      class SubSampleObjectType extends SampleObjectType {94        @Field()95        withInput(@Arg("input") input: SubDirectiveOnFieldInput): string {96          return `hello${input.append}`;97        }98      }99      @InterfaceType()100      @Directive("foo")101      abstract class DirectiveOnInterface {102        @Field()103        @Directive("bar")104        withDirective: string;105      }106      @ObjectType({ implements: DirectiveOnInterface })107      class ObjectImplement extends DirectiveOnInterface {}108      @Resolver()109      class SampleResolver {110        @Query(() => SampleObjectType)111        objectType(): SampleObjectType {112          return new SampleObjectType();113        }114        @Query()115        @Directive("foo")116        queryWithDirective(): string {117          return "queryWithDirective";118        }119        // @Query()120        // @Directive("bar", { baz: "true" })121        // queryWithDirectiveWithArgs(): string {122        //   return "queryWithDirectiveWithArgs";123        // }124        @Query()125        @Directive("upper")126        queryWithUpper(): string {127          return "queryWithUpper";128        }129        @Query()130        @Directive("@upper")131        queryWithUpperDefinition(): string {132          return "queryWithUpper";133        }134        @Query()135        @Directive("append")136        queryWithAppend(): string {137          return "hello";138        }139        @Query()140        @Directive("@append")141        queryWithAppendDefinition(): string {142          return "hello";143        }144        @Query()145        @Directive("append")146        @Directive("upper")147        queryWithUpperAndAppend(): string {148          return "hello";149        }150        @Mutation()151        @Directive("foo")152        mutationWithDirective(): string {153          return "mutationWithDirective";154        }155        // @Mutation()156        // @Directive("bar", { baz: "true" })157        // mutationWithDirectiveWithArgs(): string {158        //   return "mutationWithDirectiveWithArgs";159        // }160        @Mutation()161        @Directive("upper")162        mutationWithUpper(): string {163          return "mutationWithUpper";164        }165        @Mutation()166        @Directive("@upper")167        mutationWithUpperDefinition(): string {168          return "mutationWithUpper";169        }170        @Mutation()171        @Directive("append")172        mutationWithAppend(): string {173          return "hello";174        }175        @Mutation()176        @Directive("@append")177        mutationWithAppendDefinition(): string {178          return "hello";179        }180        @Mutation()181        @Directive("append")182        @Directive("upper")183        mutationWithUpperAndAppend(): string {184          return "hello";185        }186        @Subscription({ topics: "TEST" })187        @Directive("@foo")188        subscriptionWithDirective(): string {189          return "subscriptionWithDirective";190        }191      }192      @Resolver(of => SampleObjectType)193      class SampleObjectTypeResolver {194        @FieldResolver()195        @Directive("@append")196        fieldResolverWithAppendDefinition(): string {197          return "hello";198        }199      }200      @Resolver(of => SubSampleObjectType)201      class SubSampleResolver {202        @Query(() => SubSampleObjectType)203        subObjectType(): SubSampleObjectType {204          return new SubSampleObjectType();205        }206      }207      @Resolver(() => ObjectImplement)208      class ObjectImplementResolver {209        @Query(() => ObjectImplement)210        objectImplentingInterface(): ObjectImplement {211          return new ObjectImplement();212        }213      }214      schema = await buildSchema({215        resolvers: [216          SampleResolver,217          SampleObjectTypeResolver,218          SubSampleResolver,219          ObjectImplementResolver,220        ],221        validate: false,222      });223      SchemaDirectiveVisitor.visitSchemaDirectives(schema, {224        upper: UpperCaseDirective,225        append: AppendDirective,226      });227    });228    it("should generate schema without errors", async () => {229      expect(schema).toBeDefined();230    });231    describe("Query", () => {232      it("should add directives to query types", async () => {233        const queryWithDirective = schema.getQueryType()!.getFields().queryWithDirective;234        assertValidDirective(queryWithDirective.astNode, "foo");235      });236      // it("should add directives to query types with arguments", async () => {237      //   const queryWithDirectiveWithArgs = schema.getQueryType()!.getFields()238      //     .queryWithDirectiveWithArgs;239      //   assertValidDirective(queryWithDirectiveWithArgs.astNode, "bar", { baz: "true" });240      // });241      it("calls directive 'upper'", async () => {242        const query = `query {243          queryWithUpper244        }`;245        const { data } = await graphql(schema, query);246        expect(data).toHaveProperty("queryWithUpper", "QUERYWITHUPPER");247      });248      it("calls directive 'upper' using Definition", async () => {249        const query = `query {250          queryWithUpperDefinition251        }`;252        const { data } = await graphql(schema, query);253        expect(data).toHaveProperty("queryWithUpperDefinition", "QUERYWITHUPPER");254      });255      it("calls directive 'append'", async () => {256        const query = `query {257          queryWithAppend(append: ", world!")258        }`;259        const { data } = await graphql(schema, query);260        expect(data).toHaveProperty("queryWithAppend", "hello, world!");261      });262      it("calls directive 'append' using Definition", async () => {263        const query = `query {264          queryWithAppendDefinition(append: ", world!")265        }`;266        const { data } = await graphql(schema, query);267        expect(data).toHaveProperty("queryWithAppendDefinition", "hello, world!");268      });269      it("calls directive 'upper' and 'append'", async () => {270        const query = `query {271          queryWithUpperAndAppend(append: ", world!")272        }`;273        const { data } = await graphql(schema, query);274        expect(data).toHaveProperty("queryWithUpperAndAppend", "HELLO, WORLD!");275      });276    });277    describe("Mutation", () => {278      it("should add directives to mutation types", async () => {279        const mutationWithDirective = schema.getMutationType()!.getFields().mutationWithDirective;280        assertValidDirective(mutationWithDirective.astNode, "foo");281      });282      // it("should add directives to mutation types with arguments", async () => {283      //   const mutationWithDirectiveWithArgs = schema.getMutationType()!.getFields()284      //     .mutationWithDirectiveWithArgs;285      //   assertValidDirective(mutationWithDirectiveWithArgs.astNode, "bar", { baz: "true" });286      // });287      it("calls directive 'upper'", async () => {288        const mutation = `mutation {289          mutationWithUpper290        }`;291        const { data } = await graphql(schema, mutation);292        expect(data).toHaveProperty("mutationWithUpper", "MUTATIONWITHUPPER");293      });294      it("calls directive 'upper' using Definition", async () => {295        const mutation = `mutation {296          mutationWithUpperDefinition297        }`;298        const { data } = await graphql(schema, mutation);299        expect(data).toHaveProperty("mutationWithUpperDefinition", "MUTATIONWITHUPPER");300      });301      it("calls directive 'append'", async () => {302        const mutation = `mutation {303          mutationWithAppend(append: ", world!")304        }`;305        const { data } = await graphql(schema, mutation);306        expect(data).toHaveProperty("mutationWithAppend", "hello, world!");307      });308      it("calls directive 'append' using Definition", async () => {309        const mutation = `mutation {310          mutationWithAppendDefinition(append: ", world!")311        }`;312        const { data } = await graphql(schema, mutation);313        expect(data).toHaveProperty("mutationWithAppendDefinition", "hello, world!");314      });315      it("calls directive 'upper' and 'append'", async () => {316        const mutation = `mutation {317          mutationWithUpperAndAppend(append: ", world!")318        }`;319        const { data } = await graphql(schema, mutation);320        expect(data).toHaveProperty("mutationWithUpperAndAppend", "HELLO, WORLD!");321      });322    });323    describe("Subscription", () => {324      it("should add directives to subscription types", async () => {325        const subscriptionWithDirective = schema.getSubscriptionType()!.getFields()326          .subscriptionWithDirective;327        assertValidDirective(subscriptionWithDirective.astNode, "foo");328      });329    });330    describe("InputType", () => {331      it("adds field directive to input types", async () => {332        const inputType = schema.getType("DirectiveOnClassInput") as GraphQLInputObjectType;333        expect(inputType).toHaveProperty("astNode");334        assertValidDirective(inputType.astNode, "upper");335      });336      it("adds field directives to input type fields", async () => {337        const fields = (schema.getType(338          "DirectiveOnFieldInput",339        ) as GraphQLInputObjectType).getFields();340        expect(fields).toHaveProperty("append");341        expect(fields.append).toHaveProperty("astNode");342        assertValidDirective(fields.append.astNode, "upper");343      });344      it("adds inherited field directives to input type fields while extending input type class", async () => {345        const fields = (schema.getType(346          "SubDirectiveOnFieldInput",347        ) as GraphQLInputObjectType).getFields();348        expect(fields).toHaveProperty("append");349        expect(fields.append).toHaveProperty("astNode");350        assertValidDirective(fields.append.astNode, "upper");351      });352    });353    describe("ObjectType", () => {354      it("calls object type directives", async () => {355        const query = `query {356          objectType {357            withDirective358            # withDirectiveWithArgs359            withUpper360            withUpperDefinition361            withAppend(append: ", world!")362            withAppendDefinition(append: ", world!")363            withUpperAndAppend(append: ", world!")364            withInput(input: { append: ", world!" })365            withInputUpper(input: { append: ", world!" })366            withInputOnClass(input: { append: ", world!" })367            withInputUpperOnClass(input: { append: ", world!" })368            fieldResolverWithAppendDefinition(append: ", world!")369          }370      }`;371        const { data } = await graphql(schema, query);372        expect(data).toHaveProperty("objectType");373        expect(data!.objectType).toEqual({374          withDirective: "withDirective",375          // withDirectiveWithArgs: "withDirectiveWithArgs",376          withUpper: "WITHUPPER",377          withUpperDefinition: "WITHUPPERDEFINITION",378          withAppend: "hello, world!",379          withAppendDefinition: "hello, world!",380          withUpperAndAppend: "HELLO, WORLD!",381          withInput: "hello, WORLD!",382          withInputUpper: "HELLO, WORLD!",383          withInputOnClass: "hello, WORLD!",384          withInputUpperOnClass: "HELLO, WORLD!",385          fieldResolverWithAppendDefinition: "hello, world!",386        });387      });388      it("call object type directives while extending field type class", async () => {389        const query = `query {390          subObjectType {391            withDirective392            # withDirectiveWithArgs393            withUpper394            withUpperDefinition395            withAppend(append: ", world!")396            withAppendDefinition(append: ", world!")397            withUpperAndAppend(append: ", world!")398            withInput(input: { append: ", world!" })399            withInputUpper(input: { append: ", world!" })400            withInputOnClass(input: { append: ", world!" })401            withInputUpperOnClass(input: { append: ", world!" })402            fieldResolverWithAppendDefinition(append: ", world!")403          }404      }`;405        const { data } = await graphql(schema, query);406        expect(data).toHaveProperty("subObjectType");407        expect(data!.subObjectType).toEqual({408          withDirective: "withDirective",409          // withDirectiveWithArgs: "withDirectiveWithArgs",410          withUpper: "WITHUPPER",411          withUpperDefinition: "WITHUPPERDEFINITION",412          withAppend: "hello, world!",413          withAppendDefinition: "hello, world!",414          withUpperAndAppend: "HELLO, WORLD!",415          withInput: "hello, WORLD!",416          withInputUpper: "HELLO, WORLD!",417          withInputOnClass: "hello, WORLD!",418          withInputUpperOnClass: "HELLO, WORLD!",419          fieldResolverWithAppendDefinition: "hello, world!",420        });421      });422    });423    describe("Interface", () => {424      it("adds directive to interface", () => {425        const interfaceType = schema.getType("DirectiveOnInterface") as GraphQLInterfaceType;426        expect(interfaceType).toHaveProperty("astNode");427        assertValidDirective(interfaceType.astNode, "foo");428      });429      it("adds field directives to interface fields", async () => {430        const fields = (schema.getType("DirectiveOnInterface") as GraphQLInterfaceType).getFields();431        expect(fields).toHaveProperty("withDirective");432        expect(fields.withDirective).toHaveProperty("astNode");433        assertValidDirective(fields.withDirective.astNode, "bar");434      });435      it("adds inherited field directives to object type fields while extending interface type class", async () => {436        const fields = (schema.getType("ObjectImplement") as GraphQLObjectType).getFields();437        expect(fields).toHaveProperty("withDirective");438        expect(fields.withDirective).toHaveProperty("astNode");439        assertValidDirective(fields.withDirective.astNode, "bar");440      });441    });442  });443  describe("errors", () => {444    beforeEach(async () => {445      getMetadataStorage().clear();446    });447    it("throws error on multiple directive definitions", async () => {448      expect.assertions(2);449      @Resolver()450      class InvalidQuery {451        @Query()452        @Directive("@upper @append")453        invalid(): string {454          return "invalid";455        }456      }457      try {458        await buildSchema({ resolvers: [InvalidQuery] });459      } catch (err) {460        expect(err).toBeInstanceOf(InvalidDirectiveError);461        const error: InvalidDirectiveError = err;462        expect(error.message).toContain(463          'Please pass only one directive name or definition at a time to the @Directive decorator "@upper @append"',464        );465      }466    });467    it("throws error when parsing invalid directives", async () => {468      expect.assertions(2);469      @Resolver()470      class InvalidQuery {471        @Query()472        @Directive("@invalid(@directive)")473        invalid(): string {474          return "invalid";475        }476      }477      try {478        await buildSchema({ resolvers: [InvalidQuery] });479      } catch (err) {480        expect(err).toBeInstanceOf(InvalidDirectiveError);481        const error: InvalidDirectiveError = err;482        expect(error.message).toContain(483          'Error parsing directive definition "@invalid(@directive)"',484        );485      }486    });487    it("throws error when no directives are defined", async () => {488      expect.assertions(2);489      @Resolver()490      class InvalidQuery {491        @Query()492        @Directive("")493        invalid(): string {494          return "invalid";495        }496      }497      try {498        await buildSchema({ resolvers: [InvalidQuery] });499      } catch (err) {500        expect(err).toBeInstanceOf(InvalidDirectiveError);501        const error: InvalidDirectiveError = err;502        expect(error.message).toContain(503          "Please pass at-least one directive name or definition to the @Directive decorator",504        );505      }506    });507  });...

test.spec.ts

Source:test.spec.ts

...55      });56      it('succeeds with the directive', () => {57        expect(withDirective).not.toThrow();58        target = 0;59        expect(ngMocks.formatText(withDirective())).toEqual(60          'target:1',61        );62        expect(ngMocks.formatText(withDirective())).toEqual(63          'target:2',64        );65        expect(ngMocks.formatText(withDirective())).toEqual(66          'target:3',67        );68      });69    });70    describe('with-provider', () => {71      ngMocks.faster();72      beforeAll(() =>73        TestBed.configureTestingModule({74          imports: [TargetModule],75          providers: [TargetService],76        }),77      );78      beforeAll(() => withoutDirective.configureTestBed());79      beforeAll(() => withDirective.configureTestBed());80      // a single instance is used81      it('fallbacks without the directive', () => {82        target = 0;83        expect(withoutDirective).not.toThrow();84        expect(ngMocks.formatText(withoutDirective())).toEqual(85          'target:1',86        );87        expect(ngMocks.formatText(withoutDirective())).toEqual(88          'target:1',89        );90        expect(ngMocks.formatText(withoutDirective())).toEqual(91          'target:1',92        );93      });94      // an instance is created on every render95      it('uses the directive', () => {96        target = 0;97        expect(withDirective).not.toThrow();98        expect(ngMocks.formatText(withDirective())).toEqual(99          'target:2',100        );101        expect(ngMocks.formatText(withDirective())).toEqual(102          'target:3',103        );104        expect(ngMocks.formatText(withDirective())).toEqual(105          'target:4',106        );107      });108    });109  });110  describe('MockBuilder', () => {111    describe('without-provider', () => {112      ngMocks.faster();113      beforeAll(() => MockBuilder(TargetComponent, TargetModule));114      beforeAll(() => withoutDirective.configureTestBed());115      beforeAll(() => withDirective.configureTestBed());116      it('fails without the directive', () => {117        expect(withoutDirective).toThrowError(118          /No provider for TargetService/,119        );120      });121      it('succeeds with the directive', () => {122        expect(withDirective).not.toThrow();123        // a mock service returns empty name124        expect(ngMocks.formatText(withDirective())).toEqual('');125        expect(ngMocks.formatText(withDirective())).toEqual('');126        expect(ngMocks.formatText(withDirective())).toEqual('');127      });128    });129    describe('w/ provider w/o export', () => {130      beforeEach(() =>131        MockBuilder(TargetComponent, TargetModule).mock(132          TargetService,133        ),134      );135      beforeEach(() => withoutDirective.configureTestBed());136      it('fails without export', () => {137        expect(withoutDirective).toThrowError(138          /No provider for TargetService/,139        );140      });...

with.module.ts

Source:with.module.ts

1import { NgModule } from '@angular/core';2import { WithDirective } from './with.directive';3@NgModule({4  declarations: [WithDirective],5  exports: [WithDirective],6})...

Using AI Code Generation

1import { withDirective } from 'ng-mocks';2import { MyDirective } from './my.directive';3describe('MyDirective', () => {4  it('should create an instance', () => {5    const directive = withDirective(MyDirective);6    expect(directive).toBeTruthy();7  });8});9import { Directive } from '@angular/core';10@Directive({11})12export class MyDirective {13  constructor() { }14}15{16  "compilerOptions": {17  },18}19{20  "compilerOptions": {21    "importHelpers": true,22  }23}24module.exports = function (config) {25  config.set({26      require('karma-jasmine'),27      require('karma-chrome-launcher'),28      require('karma-coverage-istanbul-reporter'),29      require('karma-jasmine-html-reporter'),30      require('karma-spec-reporter'),31      require('@angular-devkit/build-angular/plugins/karma')32    client: {33    },34    coverageIstanbulReporter: {35      dir: require('path').join(__dirname, './coverage/ng-mocks'),

Using AI Code Generation

1import { withDirective } from 'ng-mocks';2import { MyDirective } from './my-directive';3describe('MyDirective', () => {4  it('should create an instance', () => {5    const directive = withDirective(MyDirective);6    expect(directive).toBeTruthy();7  });8});9import { Directive } from '@angular/core';10@Directive({11})12export class MyDirective {13  constructor() { }14}

Using AI Code Generation

1import {withDirective} from 'ng-mocks';2import {MyDirective} from './my.directive';3describe('MyDirective', () => {4  it('should render', () => {5    const fixture = withDirective(MyDirective);6    expect(fixture.nativeElement.innerHTML).toContain('my directive');7  });8});9import {Directive, HostBinding} from '@angular/core';10@Directive({11})12export class MyDirective {13  @HostBinding('innerHTML')14  public readonly text = 'my directive';15}

Using AI Code Generation

1import {withDirective} from 'ng-mocks';2import {withProvider} from 'ng-mocks';3describe('TestComponent', () => {4  it('should create an instance', () => {5    const component = withDirective(6      MockDirective({7      }),8    );9    expect(component).toBeTruthy();10  });11  it('should create an instance', () => {12    const component = withProvider(13      MockProvider({14        useValue: {},15      }),16    );17    expect(component).toBeTruthy();18  });19});20import {Component} from '@angular/core';21@Component({22})23export class TestComponent {}24import {Injectable} from '@angular/core';25@Injectable()26export class TestService {}

Using AI Code Generation

1import { withDirective } from 'ng-mocks';2describe('MyComponent', () => {3  it('should have a directive', () => {4    const fixture = withDirective(MyComponent, MyDirective);5    const element = fixture.nativeElement;6    expect(element.querySelector('div')).toBeDefined();7  });8});

Using AI Code Generation

1describe('withDirective', () => {2  it('should render the directive', () => {3    const fixture = MockRender(`4    `, {5      declarations: withDirective(TestComponent),6    });7    expect(fixture.point.componentInstance).toBeDefined();8  });9});10@Component({11})12export class TestComponent { }13import { MockRender } from 'ng-mocks';14import { TestComponent } from './test.component';15describe('TestComponent', () => {16  it('should create', () => {17    const fixture = MockRender(TestComponent);18    expect(fixture.point.componentInstance).toBeDefined();19  });20});21import { MockRender } from 'ng-mocks';22import { TestComponent } from './test.component';23describe('TestComponent', () => {24  it('should create', () => {25    const fixture = MockRender(TestComponent);26    expect(fixture.point.componentInstance).toBeDefined();27  });28});29import { MockRender } from 'ng-mocks';30import { TestComponent } from './test.component';31describe('TestComponent', () => {32  it('should create', () => {33    const fixture = MockRender(TestComponent);34    expect(fixture.point.componentInstance).toBeDefined();35  });36});37import { MockRender } from 'ng-mocks';38import { TestComponent } from './test.component';39describe('TestComponent', () => {40  it('should create', () => {41    const fixture = MockRender(TestComponent);42    expect(fixture.point.componentInstance).toBeDefined();43  });44});45import { MockRender } from 'ng-mocks';46import { TestComponent } from './test.component';47describe('TestComponent', () => {48  it('should create', () => {

Using AI Code Generation

1var mock = ngMocks.findInstance(BarComponent);2ngMocks.withDirective(mock, FooDirective, { selector: 'foo' });3var mock = ngMocks.findInstance(BarComponent);4ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' } });5var mock = ngMocks.findInstance(BarComponent);6ngMocks.withDirective(mock, FooDirective, { selector: 'foo', outputs: { foo: 'bar' } });7var mock = ngMocks.findInstance(BarComponent);8ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' }, outputs: { foo: 'bar' } });9var mock = ngMocks.findInstance(BarComponent);10ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' }, outputs: { foo: 'bar' }, host: { class: 'foo' } });11var mock = ngMocks.findInstance(BarComponent);12ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' }, outputs: { foo: 'bar' }, host: { class: 'foo' }, providers: [FooService] });13var mock = ngMocks.findInstance(BarComponent);14ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' }, outputs: { foo: 'bar' }, host: { class: 'foo' }, providers: [FooService], exportAs: 'foo' });15var mock = ngMocks.findInstance(BarComponent);16ngMocks.withDirective(mock, FooDirective, { selector: 'foo', inputs: { foo: 'bar' }, outputs: { foo: 'bar' }, host: { class:

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.