soda-test/dist/test-lib/testbed.d.ts

Package for Unit and API tests

/// <reference types="node" />
import { EventEmitter } from 'events';
import { argumentDecorator } from '.';
export declare const TestBed: TestBedInterface;
export declare function getInitTestBedFunction(): () => void;
export interface FixtureOptions {
    declarations?: unknown[];
    imports?: unknown[];
    inputs?: string[];
    outputs?: string[];
    events?: string[];
}
export declare function fixture<T>(component: Type<T>, options?: FixtureOptions): argumentDecorator;
export declare function component<T>(component: Type<T>): argumentDecorator;
type ANY = any;
type AFunction = Function;
export declare function createFixture<T>(component: Type<T>, options: FixtureOptions): SodaFixture<T>;
export declare function addEvents(...names: string[]): void;
export declare function createComponent<T>(component: Type<T>): T;
export interface TestBedInterface {
    get platform(): PlatformRef;
    get ngModule(): Type<ANY> | Type<ANY>[];
    initTestEnvironment(ngModule: Type<ANY> | Type<ANY>[], platform: PlatformRef, options?: TestEnvironmentOptions): void;
    resetTestEnvironment(): void;
    resetTestingModule(): TestBedInterface;
    configureCompiler(config: {
        providers?: ANY[];
        useJit?: boolean;
    }): void;
    configureTestingModule(moduleDef: TestModuleMetadata): TestBedInterface;
    compileComponents(): Promise<ANY>;
    inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
    inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T | null;
    /** @deprecated from v9.0.0 use TestBed.inject */
    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): ANY;
    /** @deprecated from v9.0.0 use TestBed.inject */
    get(token: ANY, notFoundValue?: ANY): ANY;
    execute(tokens: ANY[], fn: AFunction, context?: ANY): ANY;
    overrideModule(ngModule: Type<ANY>, override: MetadataOverride<NgModule>): TestBedInterface;
    overrideComponent(component: Type<ANY>, override: MetadataOverride<Component>): TestBedInterface;
    overrideDirective(directive: Type<ANY>, override: MetadataOverride<Directive>): TestBedInterface;
    overridePipe(pipe: Type<ANY>, override: MetadataOverride<Pipe>): TestBedInterface;
    overrideTemplate(component: Type<ANY>, template: string): TestBedInterface;
    overrideProvider(token: ANY, provider: {
        useFactory: AFunction;
        deps: ANY[];
    }): TestBedInterface;
    overrideProvider(token: ANY, provider: {
        useValue: ANY;
    }): TestBedInterface;
    overrideProvider(token: ANY, provider: {
        useFactory?: AFunction;
        useValue?: ANY;
        deps?: ANY[];
    }): TestBedInterface;
    overrideTemplateUsingTestingModule(component: Type<ANY>, template: string): TestBedInterface;
    createComponent<T>(component: Type<T>): ComponentFixture<T>;
}
export interface ComponentFixture<T, DET = DebugElement> {
    ngZone: NgZone | null;
    debugElement: DET;
    componentInstance: T;
    nativeElement: ANY;
    detectChanges(checkNoChanges?: boolean): void;
    checkNoChanges(): void;
    autoDetectChanges(autoDetect?: boolean): void;
    isStable(): boolean;
    whenStable(): Promise<ANY>;
    whenRenderingDone(): Promise<ANY>;
    destroy(): void;
}
export interface CommonEvents {
    click(eventObj?: PointerEvent): void;
    input(eventObj?: InputEvent): void;
    ngModelChange(text: string): void;
}
export interface SodaFixture<T, E = CommonEvents> extends ComponentFixture<T, SodaDebugElement<E>> {
    queryByCss<E1 = E>(selector: string): SodaDebugElement<E1>;
    get inputs(): {
        [key: string]: ANY;
    };
    get events(): EventEmitter;
}
export interface ComponentRef<C> {
    setInput(name: string, value: unknown): void;
    get location(): ElementRef;
    get injector(): Injector;
    get instance(): C;
    get hostView(): ViewRef;
    get changeDetectorRef(): ChangeDetectorRef;
    get componentType(): Type<ANY>;
    destroy(): void;
    onDestroy(callback: AFunction): void;
}
export interface NgZone {
    readonly hasPendingMacrotasks: boolean;
    readonly hasPendingMicrotasks: boolean;
    readonly isStable: boolean;
    readonly onUnstable: EventEmitter;
    readonly onMicrotaskEmpty: EventEmitter;
    readonly onStable: EventEmitter;
    readonly onError: EventEmitter;
    run<T>(fn: (...args: ANY[]) => T, applyThis?: ANY, applyArgs?: ANY[]): T;
    runTask<T>(fn: (...args: ANY[]) => T, applyThis?: ANY, applyArgs?: ANY[], name?: string): T;
    runGuarded<T>(fn: (...args: ANY[]) => T, applyThis?: ANY, applyArgs?: ANY[]): T;
    runOutsideAngular<T>(fn: (...args: ANY[]) => T): T;
}
interface DebugElementBase<DET> extends DebugNode<DET> {
    get nativeElement(): HTMLElement;
    get name(): string;
    get properties(): {
        [key: string]: ANY;
    };
    get attributes(): {
        [key: string]: string | null;
    };
    get styles(): {
        [key: string]: string | null;
    };
    get classes(): {
        [key: string]: boolean;
    };
    get childNodes(): DebugNode<DET>[];
    get children(): DET[];
}
export interface DebugElement extends DebugElementBase<DebugElement> {
    query(predicate: Predicate<DebugElement>): DebugElement;
    queryAll(predicate: Predicate<DebugElement>): DebugElement[];
    queryAllNodes(predicate: Predicate<DebugNode<DebugElement>>): DebugNode<DebugElement>[];
    triggerEventHandler(eventName: string, eventObj?: unknown): void;
}
export interface SodaDebugElement<E = CommonEvents> extends DebugElementBase<SodaDebugElement> {
    text: string;
    query: {
        by: {
            css<E1 = E>(selector: string): SodaDebugElement<E1>;
        };
    };
    queryAll: {
        by: {
            css<E1 = E>(selector: string): SodaDebugElement<E1>[];
        };
    };
    queryAllNodes: {
        by: {
            directive<E1 = E>(type: Type<ANY>): DebugNode<SodaDebugElement<E1>>[];
            all<E1 = E>(): DebugNode<SodaDebugElement<E1>>[];
        };
    };
    triggerEventHandler: E;
}
export interface ElementRef<T = ANY> {
    nativeElement: T;
}
export interface ChangeDetectorRef {
    markForCheck(): void;
    detach(): void;
    detectChanges(): void;
    checkNoChanges(): void;
    reattach(): void;
}
export interface Injector {
    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
    get(token: ANY, notFoundValue?: ANY): ANY;
}
export interface ViewRef extends ChangeDetectorRef {
    destroy(): void;
    get destroyed(): boolean;
    onDestroy(callback: AFunction): ANY;
}
export interface DebugNode<DET> {
    readonly nativeNode: ANY;
    get parent(): DET | null;
    get injector(): Injector;
    get componentInstance(): ANY;
    get context(): ANY;
    get listeners(): DebugEventListener[];
    get references(): {
        [key: string]: ANY;
    };
    get providerTokens(): ANY[];
}
export interface DebugEventListener {
    name: string;
    callback: AFunction;
}
export interface Type<T> extends AFunction {
    new (...args: unknown[]): T;
}
export declare enum InjectFlags {
    Default = 0,
    Host = 1,
    Self = 2,
    SkipSelf = 4,
    Optional = 8
}
export interface PlatformRef {
    bootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>, options?: BootstrapOptions): Promise<NgModuleRef<M>>;
    bootstrapModule<M>(moduleType: Type<M>, compilerOptions?: (CompilerOptions & BootstrapOptions) | Array<CompilerOptions & BootstrapOptions>): Promise<NgModuleRef<M>>;
    onDestroy(callback: () => void): void;
    get injector(): Injector;
    destroy(): void;
    get destroyed(): boolean;
}
export interface NgModuleFactory<T> {
    get moduleType(): Type<T>;
    create(parentInjector: Injector | null): NgModuleRef<T>;
}
export interface NgModuleRef<T> {
    get injector(): EnvironmentInjector;
    get componentFactoryResolver(): ComponentFactoryResolver;
    get instance(): T;
    destroy(): void;
    onDestroy(callback: () => void): void;
}
export interface EnvironmentInjector extends Injector {
    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
    get(token: ANY, notFoundValue?: ANY): ANY;
    runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
    destroy(): void;
}
export interface ComponentFactoryResolver {
    resolveComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
}
export interface ComponentFactory<C> {
    get selector(): string;
    componentType(): Type<ANY>;
    get ngContentSelectors(): string[];
    get inputs(): {
        propName: string;
        templateName: string;
    }[];
    get outputs(): {
        propName: string;
        templateName: string;
    }[];
    create(injector: Injector, projectableNodes?: ANY[][], rootSelectorOrNode?: string | ANY, environmentInjector?: EnvironmentInjector | NgModuleRef<ANY>): ComponentRef<C>;
}
export interface NgModule {
    providers?: Provider[];
    declarations?: Array<Type<ANY> | ANY[]>;
    imports?: Array<Type<ANY> | ModuleWithProviders<ANY> | ANY[]>;
    exports?: Array<Type<ANY> | ANY[]>;
    entryComponents?: Array<Type<ANY> | ANY[]>;
    bootstrap?: Array<Type<ANY> | ANY[]>;
    schemas?: Array<SchemaMetadata | ANY[]>;
    id?: string;
    jit?: true;
}
export interface Component extends Directive {
    changeDetection?: ChangeDetectionStrategy;
    viewProviders?: Provider[];
    moduleId?: string;
    templateUrl?: string;
    template?: string;
    styleUrls?: string[];
    styles?: string[];
    animations?: ANY[];
    encapsulation?: ViewEncapsulation;
    interpolation?: [string, string];
    entryComponents?: Array<Type<ANY> | ANY[]>;
    preserveWhitespaces?: boolean;
    standalone?: boolean;
    imports?: (Type<ANY> | ANY[])[];
    schemas?: SchemaMetadata[];
}
export interface Directive {
    selector?: string;
    inputs?: string[];
    outputs?: string[];
    providers?: Provider[];
    exportAs?: string;
    queries?: {
        [key: string]: ANY;
    };
    host?: {
        [key: string]: string;
    };
    jit?: true;
    standalone?: boolean;
}
export interface Pipe {
    name: string;
    pure?: boolean;
    standalone?: boolean;
}
export declare enum ChangeDetectionStrategy {
    OnPush = 0,
    Default = 1
}
export declare enum ViewEncapsulation {
    Emulated = 0,
    None = 2,
    ShadowDom = 3
}
export interface TestModuleMetadata {
    providers?: ANY[];
    declarations?: ANY[];
    imports?: ANY[];
    schemas?: Array<SchemaMetadata | ANY[]>;
    teardown?: ModuleTeardownOptions;
    errorOnUnknownElements?: boolean;
    errorOnUnknownProperties?: boolean;
}
interface ModuleTeardownOptions {
    destroyAfterEach: boolean;
    rethrowErrors?: boolean;
}
export type MetadataOverride<T> = {
    add?: Partial<T>;
    remove?: Partial<T>;
    set?: Partial<T>;
};
export interface TestEnvironmentOptions {
    teardown?: ModuleTeardownOptions;
    errorOnUnknownElements?: boolean;
    errorOnUnknownProperties?: boolean;
}
export interface Predicate<T> {
    (value: T): boolean;
}
export type ProviderToken<T> = Type<T> | AbstractType<T>;
interface AbstractType<T> extends AFunction {
    prototype: T;
}
export interface BootstrapOptions {
    ngZone?: NgZone | 'zone.js' | 'noop';
    ngZoneEventCoalescing?: boolean;
    ngZoneRunCoalescing?: boolean;
}
export type CompilerOptions = {
    useJit?: boolean;
    defaultEncapsulation?: ViewEncapsulation;
    providers?: StaticProvider[];
    missingTranslation?: MissingTranslationStrategy;
    preserveWhitespaces?: boolean;
};
type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | ANY[];
interface ValueProvider extends ValueSansProvider {
    provide: ANY;
    multi?: boolean;
}
interface ValueSansProvider {
    useValue: ANY;
}
interface ExistingProvider extends ExistingSansProvider {
    provide: ANY;
    multi?: boolean;
}
interface ExistingSansProvider {
    useExisting: ANY;
}
interface StaticClassProvider extends StaticClassSansProvider {
    provide: ANY;
    multi?: boolean;
}
interface StaticClassSansProvider {
    useClass: Type<ANY>;
    deps: ANY[];
}
interface ConstructorProvider extends ConstructorSansProvider {
    provide: Type<ANY>;
    multi?: boolean;
}
interface ConstructorSansProvider {
    deps?: ANY[];
}
interface FactoryProvider extends FactorySansProvider {
    provide: ANY;
    multi?: boolean;
}
interface FactorySansProvider {
    useFactory: AFunction;
    deps?: ANY[];
}
declare enum MissingTranslationStrategy {
    Error = 0,
    Warning = 1,
    Ignore = 2
}
export type Provider = Type<ANY> | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | ANY[];
interface ClassProvider extends ClassSansProvider {
    provide: ANY;
    multi?: boolean;
}
interface ClassSansProvider {
    useClass: Type<ANY>;
}
export interface ModuleWithProviders<T> {
    ngModule: Type<T>;
    providers?: Provider[];
}
export interface SchemaMetadata {
    name: string;
}
export {};