coveo-search-ui-tests/bin/ts/CoveoJsSearchTests.d.ts

Testing framework for the Coveo JavaScript Search Framework

// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../../coveo-search-ui

declare module "CoveoJsSearchTests" {
  import * as Fake from "CoveoJsSearchTests/Fake";
  import * as Mock from "CoveoJsSearchTests/MockEnvironment";
  import * as Simulate from "CoveoJsSearchTests/Simulate";
  export { Fake, Mock, Simulate };
}

declare module "CoveoJsSearchTests/Fake" {
  export * from "CoveoJsSearchTests/Fake/FakeAnalyticsEvents";
  export * from "CoveoJsSearchTests/Fake/FakeEventArgs";
  export * from "CoveoJsSearchTests/Fake/FakeFields";
  export * from "CoveoJsSearchTests/Fake/FakeGroupBy";
  export * from "CoveoJsSearchTests/Fake/FakeResults";
}

declare module "CoveoJsSearchTests/MockEnvironment" {
  export * from "CoveoJsSearchTests/MockEnvironment/AdvancedComponentsSetup";
  export * from "CoveoJsSearchTests/MockEnvironment/BasicComponentsSetup";
  export * from "CoveoJsSearchTests/MockEnvironment/ComponentsSetup";
  export * from "CoveoJsSearchTests/MockEnvironment/MockComponents";
  export * from "CoveoJsSearchTests/MockEnvironment/MockEnvironmentBuilder";
  export * from "CoveoJsSearchTests/MockEnvironment/OptionsComponentsSetup";
}

declare module "CoveoJsSearchTests/Simulate" {
  export * from "CoveoJsSearchTests/Simulate/Actions";
  export * from "CoveoJsSearchTests/Simulate/Components";
  export * from "CoveoJsSearchTests/Simulate/Environment";
  export * from "CoveoJsSearchTests/Simulate/Modules";
  export * from "CoveoJsSearchTests/Simulate/Query";
}

declare module "CoveoJsSearchTests/Fake/FakeAnalyticsEvents" {
  import { IClickEvent, ISearchEvent } from "coveo-search-ui";
  export function createFakeSearchEvent(token?: string): ISearchEvent;
  export function createFakeClickEvent(token?: string): IClickEvent;
}

declare module "CoveoJsSearchTests/Fake/FakeEventArgs" {
  import { IOmniboxDataRow, IPopulateOmniboxEventArgs } from "coveo-search-ui";
  export function createPopulateOmniboxEventArgs(
    queryboxContent: string,
    cursorPosition: number,
    rows?: IOmniboxDataRow[]
  ): IPopulateOmniboxEventArgs;
}

declare module "CoveoJsSearchTests/Fake/FakeFields" {
  import { IIndexFieldValue } from "coveo-search-ui";
  export function createFakeFieldValue(
    token: string,
    count: number
  ): IIndexFieldValue;
  export function createFakeFieldValues(
    token: string,
    count: number
  ): IIndexFieldValue[];
}

declare module "CoveoJsSearchTests/Fake/FakeGroupBy" {
  import { IGroupByValue, IGroupByResult } from "coveo-search-ui";
  export function createFakeGroupByResult(
    field: string,
    token: string,
    count: number,
    includeComputedValues?: boolean
  ): IGroupByResult;
  export function createFakeRangeGroupByResult(
    field: string,
    start?: number,
    end?: number,
    steps?: number
  ): IGroupByResult;
  export function createFakeHierarchicalValue(
    token: string,
    currentLevel: number,
    delimitingCharacter?: string
  ): string;
  export function createFakeHierarchicalGroupByResult(
    field: string,
    token: string,
    numberOfLevel?: number,
    countByLevel?: number,
    delimitingCharacter?: string,
    includeComputedValues?: boolean,
    weirdCasing?: boolean
  ): IGroupByResult;
  export function createFakeGroupByValue(
    token: string,
    count: number,
    score?: number,
    computedValue?: number
  ): IGroupByValue;
  export function createFakeGroupByRangeValue(
    from: number,
    to: number,
    token: string,
    count: number,
    score?: number,
    computedValue?: number
  ): IGroupByValue;
}

declare module "CoveoJsSearchTests/Fake/FakeResults" {
  import { IQueryResult, IQueryResults } from "coveo-search-ui";
  export function createFakeResults(
    count?: number,
    token?: string
  ): IQueryResults;
  export function createFakeResultsWithChildResults(
    count?: number,
    numberOfChildResults?: number,
    totalNumberOfChildResult?: number
  ): IQueryResults;
  export function createFakeResult(token?: string): IQueryResult;
  export function createFakeResultWithChildResult(
    token: string,
    numberOfChildResult: number,
    totalNumberOfChildResult?: number
  ): IQueryResult;
  export function createFakeResultWithAttachments(
    token?: string,
    numberOfAttachments?: number,
    attachmentType?: string[],
    flags?: string,
    attachmentsFlags?: string[],
    withSubAttachments?: boolean
  ): IQueryResult;
  export function createFakeFeedItemResult(
    token: string,
    nbLikes?: number,
    nbTopics?: number,
    hasAttachment?: boolean
  ): IQueryResult;
}

declare module "CoveoJsSearchTests/MockEnvironment/AdvancedComponentsSetup" {
  import {
    IBasicComponentSetup,
    IComponentConstructor,
    IComponentConstructorWithModalBox,
    IBasicComponentSetupWithModalBox
  } from "CoveoJsSearchTests/MockEnvironment/ComponentsSetup";
  import { MockEnvironmentBuilder } from "CoveoJsSearchTests/MockEnvironment/MockEnvironmentBuilder";
  import {
    IComponentBindings,
    Component,
    IQueryResult,
    OS_NAME
  } from "coveo-search-ui";
  export type EnvironmentBuilderModifier = (
    env: MockEnvironmentBuilder
  ) => MockEnvironmentBuilder;
  export interface IAdvancedComponentConstructor<T> {
    new (
      element: HTMLElement,
      options: any,
      bindings: IComponentBindings,
      result: IQueryResult,
      os: OS_NAME
    ): T;
  }
  export class AdvancedComponentSetupOptions {
    element: HTMLElement;
    cmpOptions: any;
    modifyBuilder: EnvironmentBuilderModifier;
    constructor(
      element?: HTMLElement,
      cmpOptions?: any,
      modifyBuilder?: EnvironmentBuilderModifier
    );
    merge(toMerge: AdvancedComponentSetupOptions): this;
  }
  export function advancedComponentSetup<T extends Component>(
    klass: IComponentConstructor<T>,
    options?: AdvancedComponentSetupOptions
  ): IBasicComponentSetup<T>;
  export function advancedComponentSetupWithModalBox<T extends Component>(
    klass: IComponentConstructorWithModalBox<T>,
    options?: AdvancedComponentSetupOptions
  ): IBasicComponentSetupWithModalBox<T>;
  export function advancedResultComponentSetup<T extends Component>(
    klass: IAdvancedComponentConstructor<T>,
    result: IQueryResult,
    options?: AdvancedComponentSetupOptions
  ): IBasicComponentSetup<T>;
}

declare module "CoveoJsSearchTests/MockEnvironment/BasicComponentsSetup" {
  import {
    IBasicComponentSetup,
    IComponentConstructor,
    IComponentConstructorWithModalBox,
    IComponentConstructorWithResult,
    IComponentConstructorWithResultAndModalBox,
    ISearchInterfaceConstructor,
    ISearchInterfaceSetup,
    IBasicComponentSetupWithModalBox
  } from "CoveoJsSearchTests/MockEnvironment/ComponentsSetup";
  import { Component, SearchInterface } from "coveo-search-ui";
  export function basicComponentSetup<T extends Component>(
    klass: IComponentConstructor<T>,
    options?: any
  ): IBasicComponentSetup<T>;
  export function basicComponentSetupWithModalBox<T extends Component>(
    klass: IComponentConstructorWithModalBox<T>,
    options?: any
  ): IBasicComponentSetupWithModalBox<T>;
  export function basicResultComponentSetup<T extends Component>(
    klass: IComponentConstructorWithResult<T>,
    options?: any
  ): IBasicComponentSetup<T>;
  export function basicResultComponentSetupWithModalBox<T extends Component>(
    klass: IComponentConstructorWithResultAndModalBox<T>,
    options?: any
  ): IBasicComponentSetupWithModalBox<T>;
  export function basicSearchInterfaceSetup<T extends SearchInterface>(
    klass: ISearchInterfaceConstructor<T>
  ): ISearchInterfaceSetup<T>;
}

declare module "CoveoJsSearchTests/MockEnvironment/ComponentsSetup" {
  import {
    Component,
    IComponentBindings,
    ModalBox,
    IQueryResult,
    ISearchInterfaceOptions,
    SearchInterface
  } from "coveo-search-ui";
  import { IMockEnvironment } from "CoveoJsSearchTests/MockEnvironment/MockEnvironmentBuilder";
  export interface IComponentConstructor<T> {
    new (element: HTMLElement, options: any, bindings: IComponentBindings): T;
  }
  export interface IBasicComponentSetup<T extends Component> {
    env: IMockEnvironment;
    cmp: T;
  }
  export interface IComponentConstructorWithModalBox<T> {
    new (
      element: HTMLElement,
      options: any,
      bindings: IComponentBindings,
      modalBox: ModalBox.ModalBox
    ): T;
  }
  export interface IBasicComponentSetupWithModalBox<T extends Component>
    extends IBasicComponentSetup<T> {
    modalBox: ModalBox.ModalBox;
  }
  export interface IComponentConstructorWithResult<T> {
    new (
      element: HTMLElement,
      options: any,
      bindings: IComponentBindings,
      result: IQueryResult
    ): T;
  }
  export interface IComponentConstructorWithResultAndModalBox<T> {
    new (
      element: HTMLElement,
      options: any,
      bindings: IComponentBindings,
      result: IQueryResult,
      modalBox: ModalBox.ModalBox
    ): T;
  }
  export interface ISearchInterfaceConstructor<T extends SearchInterface> {
    new (
      element: HTMLElement,
      options?: ISearchInterfaceOptions,
      analyticsOptions?: any,
      _window?: Window
    ): T;
  }
  export interface ISearchInterfaceSetup<T extends SearchInterface> {
    env: IMockEnvironment;
    cmp: T;
  }
}

declare module "CoveoJsSearchTests/MockEnvironment/MockComponents" {
  import {
    BaseComponent,
    SearchInterface,
    QueryController,
    SearchEndpoint,
    IAnalyticsClient,
    AnalyticsEndpoint
  } from "coveo-search-ui";
  export type ConstructorFunc<T> = any;
  export interface IResponsiveComponentsMock {
    windoh: Window;
    /**
                * Set the breakpoint for small screen size.
                * @param width
                */
    setSmallScreenWidth(width: number): void;
    /**
                * Set the breakpoint for medium screen size
                * @param width
                */
    setMediumScreenWidth(width: number): void;
    /**
                * Get the current breakpoint for small screen size.
                *
                * If it was not explicitly set by {@link ResponsiveComponents.setSmallScreenWidth}, the default value is `480`.
                * @returns {number}
                */
    getSmallScreenWidth(): number;
    /**
                * Get the current breakpoint for medium screen size.
                *
                * If it was not explicitly set by {@link ResponsiveComponents.setMediumScreenWidth}, the default value is `800`.
                * @returns {number}
                */
    getMediumScreenWidth(): number;
    /**
                * Return true if the current screen size is smaller than the current breakpoint set for small screen width.
                * @returns {boolean}
                */
    isSmallScreenWidth(): boolean;
    /**
                * Return true if the current screen size is smaller than the current breakpoint set for medium screen width.
                * @returns {boolean}
                */
    isMediumScreenWidth(): boolean;
    /**
                * Return true if the current screen size is larger than the current breakpoint set for medium and small.
                * @returns {boolean}
                */
    isLargeScreenWidth(): boolean;
  }
  export function mock<T>(contructorFunc: ConstructorFunc<T>, name?: string): T;
  export function mockWindow(): Window;
  export function mockComponent<T extends BaseComponent>(
    constructorFunc: ConstructorFunc<T>,
    name?: string
  ): T;
  export function mockSearchInterface(): SearchInterface;
  export function mockResponsiveComponents(): IResponsiveComponentsMock;
  export function mockQueryController(): QueryController;
  export function mockSearchEndpoint(): SearchEndpoint;
  export function mockUsageAnalytics(): IAnalyticsClient;
  export function mockAnalyticsEndpoint(): AnalyticsEndpoint;
}

declare module "CoveoJsSearchTests/MockEnvironment/MockEnvironmentBuilder" {
  import {
    IComponentBindings,
    IQueryResult,
    SearchInterface,
    QueryStateModel,
    IAnalyticsClient,
    ComponentStateModel,
    ComponentOptionsModel,
    OS_NAME,
    SearchEndpoint,
    QueryController
  } from "coveo-search-ui";
  export interface IMockEnvironment extends IComponentBindings {
    root: HTMLElement;
    element: HTMLElement;
    result: IQueryResult;
    searchEndpoint: SearchEndpoint;
    searchInterface: SearchInterface;
    queryController: QueryController;
    queryStateModel: QueryStateModel;
    usageAnalytics: IAnalyticsClient;
  }
  export interface IMockEnvironmentWithData<T> extends IMockEnvironment {
    data: T;
  }
  export class MockEnvironmentBuilder {
    root: HTMLElement;
    element: HTMLElement;
    result: IQueryResult;
    searchEndpoint: SearchEndpoint;
    searchInterface: SearchInterface;
    queryController: QueryController;
    queryStateModel: QueryStateModel;
    componentStateModel: ComponentStateModel;
    usageAnalytics: IAnalyticsClient;
    componentOptionsModel: ComponentOptionsModel;
    os: OS_NAME;
    withRoot(root: HTMLElement): this;
    withElement(element: HTMLElement): this;
    withLiveQueryStateModel(): this;
    withQueryStateModel(model: QueryStateModel): this;
    withCollaborativeRating(): this;
    withOs(os: OS_NAME): this;
    withResult(result?: IQueryResult): this;
    withEndpoint(endpoint?: SearchEndpoint): this;
    build(): IMockEnvironment;
    getBindings(): IMockEnvironment;
  }
}

declare module "CoveoJsSearchTests/MockEnvironment/OptionsComponentsSetup" {
  import {
    ISearchInterfaceSetup,
    ISearchInterfaceConstructor,
    IComponentConstructorWithResult,
    IComponentConstructorWithResultAndModalBox,
    IBasicComponentSetupWithModalBox,
    IBasicComponentSetup,
    IComponentConstructor,
    IComponentConstructorWithModalBox
  } from "CoveoJsSearchTests/MockEnvironment/ComponentsSetup";
  import {
    SearchInterface,
    IQueryResult,
    ISearchInterfaceOptions,
    Component
  } from "coveo-search-ui";
  export function optionsSearchInterfaceSetup<
    T extends SearchInterface,
    U extends ISearchInterfaceOptions
  >(
    klass: ISearchInterfaceConstructor<T>,
    options: U
  ): ISearchInterfaceSetup<T>;
  export function optionsResultComponentSetup<T extends Component, U>(
    klass: IComponentConstructorWithResult<T>,
    options: U,
    result: IQueryResult
  ): IBasicComponentSetup<T>;
  export function optionsResultComponentSetupWithModalBox<
    T extends Component,
    U
  >(
    klass: IComponentConstructorWithResultAndModalBox<T>,
    options: U,
    result: IQueryResult
  ): IBasicComponentSetupWithModalBox<T>;
  export function optionsComponentSetup<T extends Component, U>(
    klass: IComponentConstructor<T>,
    options: U
  ): IBasicComponentSetup<T>;
  export function optionsComponentSetupWithModalBox<T extends Component, U>(
    klass: IComponentConstructorWithModalBox<T>,
    options: U
  ): IBasicComponentSetupWithModalBox<T>;
}

declare module "CoveoJsSearchTests/Simulate/Actions" {
  export function keyUp(
    element: HTMLElement,
    key: number,
    shiftKey?: boolean
  ): void;
}

declare module "CoveoJsSearchTests/Simulate/Components" {
  import { IMockEnvironment } from "CoveoJsSearchTests/MockEnvironment";
  import { IOmniboxData, IBreadcrumbItem } from "coveo-search-ui";
  export function omnibox(env: IMockEnvironment, options?: any): IOmniboxData;
  export function breadcrumb(
    env: IMockEnvironment,
    options?: any
  ): IBreadcrumbItem[];
}

declare module "CoveoJsSearchTests/Simulate/Environment" {
  export const JQuery: {};
  export function isPhantomJs(): boolean;
  export function isChromeHeadless(): boolean;
  export function addJQuery(): any;
  export function removeJQuery(): void;
}

declare module "CoveoJsSearchTests/Simulate/Modules" {
  import { ModalBox } from "coveo-search-ui";
  export function modalBoxModule(): ModalBox.ModalBox;
  export function analyticsStoreModule(
    actionsHistory?: CoveoAnalytics.HistoryElement[]
  ): CoveoAnalytics.HistoryStore;
}

declare module "CoveoJsSearchTests/Simulate/Query" {
  import { IMockEnvironment } from "CoveoJsSearchTests/MockEnvironment";
  import {
    QueryBuilder,
    IQuery,
    IQueryCorrection,
    IEndpointError,
    IQueryResults,
    IGroupByResult,
    Component
  } from "coveo-search-ui";
  export interface ISimulateQueryData {
    query?: IQuery;
    queryBuilder?: QueryBuilder;
    searchAsYouType?: boolean;
    promise?: Promise<IQueryResults>;
    error?: IEndpointError;
    results?: IQueryResults;
    queryCorrections?: IQueryCorrection[];
    groupByResults?: IGroupByResult[];
    callbackDuringQuery?(): void;
    callbackAfterNoResults?(): void;
    callbackAfterQuery?(): void;
    doNotFlushDefer?: boolean;
    deferSuccess?: boolean;
    cancel?: boolean;
    origin?: Component;
  }
  export function query(
    env: IMockEnvironment,
    options?: ISimulateQueryData
  ): ISimulateQueryData;
}