• Version 1.0.16
  • Published
  • 6.78 kB
  • 4 dependencies
  • MIT license


npm i @types/ember-test-helpers
yarn add @types/ember-test-helpers
pnpm add @types/ember-test-helpers


TypeScript definitions for ember-test-helpers



namespace ember-test-helpers

module 'ember-test-helpers' {}

    function getContext

    getContext: () => TestContext | undefined;

      function setContext

      setContext: (context: TestContext) => void;

        function setResolver

        setResolver: (resolver: Ember.Resolver) => void;

          function unsetContext

          unsetContext: () => void;

            class TestModule

            class TestModule {}


              constructor(name: string, callbacks?: ModuleCallbacks);


                constructor(name: string, description?: string, callbacks?: ModuleCallbacks);

                  property callbacks

                  callbacks: ModuleCallbacks;

                    property context

                    context: TestContext;

                      property description

                      description: string;

                        property isIntegration

                        isIntegration: boolean;

                          property name

                          name: string;

                            property resolver

                            resolver: Ember.Resolver;

                              property subjectName

                              subjectName: string;

                                method getContext

                                getContext: () => TestContext;

                                  method setContext

                                  setContext: (context: TestContext) => void;

                                    method setup

                                    setup: (assert?: any) => RSVP.Promise<void>;

                                      method teardown

                                      teardown: (assert?: any) => RSVP.Promise<void>;

                                        class TestModuleForAcceptance

                                        class TestModuleForAcceptance extends TestModule {}

                                          class TestModuleForComponent

                                          class TestModuleForComponent extends TestModule {}

                                            class TestModuleForIntegration

                                            class TestModuleForIntegration extends TestModule {}

                                              class TestModuleForModel

                                              class TestModuleForModel extends TestModule {}

                                                interface ModuleCallbacks

                                                interface ModuleCallbacks {}

                                                  property integration

                                                  integration?: boolean | undefined;

                                                    property needs

                                                    needs?: string[] | undefined;

                                                      property unit

                                                      unit?: boolean | undefined;

                                                        method afterTeardown

                                                        afterTeardown: (assert?: any) => void;

                                                          method beforeSetup

                                                          beforeSetup: (assert?: any) => void;

                                                            method setup

                                                            setup: (assert?: any) => void;

                                                              method teardown

                                                              teardown: (assert?: any) => void;

                                                                index signature

                                                                [key: string]: any;

                                                                  interface TestContext

                                                                  interface TestContext {}

                                                                    property $

                                                                    $: JQueryStatic;

                                                                      property application

                                                                      application: Ember.Application;

                                                                        property container

                                                                        container: Ember.Container;

                                                                          property dispatcher

                                                                          dispatcher: Ember.EventDispatcher;

                                                                            property element

                                                                            element: Element;

                                                                              property inject

                                                                              inject: {
                                                                              controller(name: string, options?: { as: string }): any;
                                                                              service(name: string, options?: { as: string }): any;

                                                                                property owner

                                                                                owner: Ember.ApplicationInstance & {
                                                                                factoryFor(fullName: string, options?: {}): any;

                                                                                  property registry

                                                                                  registry: Ember.Registry;

                                                                                    method clearRender

                                                                                    clearRender: () => void;

                                                                                      method factory

                                                                                      factory: (fullName: string) => any;

                                                                                        method get

                                                                                        get: (key: string) => any;

                                                                                          method getProperties

                                                                                          getProperties: <K extends string>(...keys: K[]) => Pick<any, K>;

                                                                                            method on

                                                                                            on: (
                                                                                            actionName: string,
                                                                                            handler: (this: TestContext, ...args: any[]) => any
                                                                                            ) => void;

                                                                                              method pauseTest

                                                                                              pauseTest: () => Promise<void>;

                                                                                                method register

                                                                                                register: (fullName: string, factory: any) => void;

                                                                                                  method render

                                                                                                  render: (template?: string | string[] | TemplateFactory) => Promise<void>;

                                                                                                    method resumeTest

                                                                                                    resumeTest: () => void;

                                                                                                      method send

                                                                                                      send: (actionName: string) => void;

                                                                                                        method set

                                                                                                        set: <V>(key: string, value: V) => V;

                                                                                                          method setProperties

                                                                                                          setProperties: <P extends { [key: string]: any }>(hash: P) => P;

                                                                                                            method subject

                                                                                                            subject: (options?: {}) => any;

                                                                                                              namespace ember-test-helpers/has-ember-version

                                                                                                              module 'ember-test-helpers/has-ember-version' {}

                                                                                                                function hasEmberVersion

                                                                                                                hasEmberVersion: (major: number, minor: number) => boolean;

                                                                                                                  namespace ember-test-helpers/wait

                                                                                                                  module 'ember-test-helpers/wait' {}

                                                                                                                    function wait

                                                                                                                    wait: (options?: WaitOptions) => RSVP.Promise<void>;

                                                                                                                      interface WaitOptions

                                                                                                                      interface WaitOptions {}

                                                                                                                        property waitForAJAX

                                                                                                                        waitForAJAX?: boolean | undefined;

                                                                                                                          property waitForTimers

                                                                                                                          waitForTimers?: boolean | undefined;

                                                                                                                            property waitForWaiters

                                                                                                                            waitForWaiters?: boolean | undefined;

                                                                                                                              Package Files (1)

                                                                                                                              Dependencies (4)

                                                                                                                              Dev Dependencies (0)

                                                                                                                              No dev dependencies.

                                                                                                                              Peer Dependencies (0)

                                                                                                                              No peer dependencies.


                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/ember-test-helpers.

                                                                                                                              • Markdown
                                                                                                                              • HTML
                                                                                                                                <a href="https://www.jsdocs.io/package/@types/ember-test-helpers"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>