@types/karma

constructor

constructor(options?: Config, callback?: ServerCallback);

constructor

constructor(options?: ConfigOptions | ConfigFile, callback?: ServerCallback);

• Deprecated

method get

get: (token: string) => any;

• Get properties from the injector

  Parameter token

method on

on: {
    (event: string, listener: (...args: any[]) => void): this;
    (
        event: 'run_complete',
        listener: (browsers: any, results: TestResults) => void
    ): this;
};

• Listen to the 'run_complete' event.

method refreshFile

refreshFile: (path: string) => Promise<any>;

method refreshFiles

refreshFiles: () => Promise<any>;

• Force a refresh of the file list

method start

start: () => Promise<void>;

• Start the server

method stop

stop: () => Promise<void>;

• Stop the server

property format

format?: string | undefined;

• The format is a string where %b, %t, %T, and %m are replaced with the browser string, log type in lower-case, log type in uppercase, and log message, respectively. This format will only effect the output file

property level

level?: 'log' | 'error' | 'warn' | 'info' | 'debug' | undefined;

• the desired log-level, where level log always is logged

property path

path?: string | undefined;

• output-path of the output-file

property terminal

terminal?: boolean | undefined;

• if the log should be written in the terminal, or not

property args

args?: string[] | undefined;

• undefined When karma run is passed additional arguments on the command-line, they are passed through to the test adapter as karma.config.args (an array of strings). The client.args option allows you to set this value for actions other than run. How this value is used is up to your test adapter - you should check your adapter's documentation to see how (and if) it uses this value.

property captureConsole

captureConsole?: boolean | undefined;

• true Capture all console output and pipe it to the terminal.

property clearContext

clearContext?: boolean | undefined;

• true Clear the context window If true, Karma clears the context window upon the completion of running the tests. If false, Karma does not clear the context window upon the completion of running the tests. Setting this to false is useful when embedding a Jasmine Spec Runner Template.

property clientDisplayNone

clientDisplayNone?: boolean | undefined;

• false Set style display none on client elements. If true, Karma does not display the banner and browser list. Useful when using karma on component tests with screenshots

property runInParent

runInParent?: boolean | undefined;

• false Run the tests on the same window as the client, without using iframe or a new window

property useIframe

useIframe?: boolean | undefined;

• true Run the tests inside an iFrame or a new window If true, Karma runs the tests inside an iFrame. If false, Karma runs the tests in a new window. Some tests may not run in an iFrame and may need a new window to run.

property LOG_DEBUG

LOG_DEBUG: string;

property LOG_DISABLE

LOG_DISABLE: string;

property LOG_ERROR

LOG_ERROR: string;

property LOG_INFO

LOG_INFO: string;

property LOG_WARN

LOG_WARN: string;

property set

set: (config: ConfigOptions) => void;

property configFile

configFile: string;

property autoWatch

autoWatch?: boolean | undefined;

• Enable or disable watching files and executing the tests whenever one of these files changes. true

property autoWatchBatchDelay

autoWatchBatchDelay?: number | undefined;

• When Karma is watching the files for changes, it tries to batch multiple changes into a single run so that the test runner doesn't try to start and restart running tests more than it should. The configuration setting tells Karma how long to wait (in milliseconds) after any changes have occurred before starting the test process again. 250

property basePath

basePath?: string | undefined;

• '' The root path location that will be used to resolve all relative paths defined in files and exclude. If the basePath configuration is a relative path then it will be resolved to the __dirname of the configuration file.

property beforeMiddleware

beforeMiddleware?: string[] | undefined;

• This is the same as middleware except that these middleware will be run before karma's own middleware. []

property browserConsoleLogOptions

browserConsoleLogOptions?: BrowserConsoleLogOptions | undefined;

• Configure how the browser console is logged with the following properties, all of which are optional

property browserDisconnectTimeout

browserDisconnectTimeout?: number | undefined;

• 2000 How long does Karma wait for a browser to reconnect (in ms). With a flaky connection it is pretty common that the browser disconnects, but the actual test execution is still running without any problems. Karma does not treat a disconnection as immediate failure and will wait browserDisconnectTimeout (ms). If the browser reconnects during that time, everything is fine.

property browserDisconnectTolerance

browserDisconnectTolerance?: number | undefined;

• 0 The number of disconnections tolerated. The disconnectTolerance value represents the maximum number of tries a browser will attempt in the case of a disconnection. Usually any disconnection is considered a failure, but this option allows you to define a tolerance level when there is a flaky network link between the Karma server and the browsers.

property browserNoActivityTimeout

browserNoActivityTimeout?: number | undefined;

• 10000 How long will Karma wait for a message from a browser before disconnecting from it (in ms). If, during test execution, Karma does not receive any message from a browser within browserNoActivityTimeout (ms), it will disconnect from the browser

property browsers

browsers?: Array<AutomatedBrowsers | string> | undefined;

• [] Possible Values: Chrome (launcher comes installed with Karma) ChromeCanary (launcher comes installed with Karma) PhantomJS (launcher comes installed with Karma) Firefox (launcher requires karma-firefox-launcher plugin) FirefoxHeadless (launcher requires karma-firefox-launcher plugin) FirefoxDeveloper (launcher requires karma-firefox-launcher plugin) FirefoxDeveloperHeadless (launcher requires karma-firefox-launcher plugin) FirefoxAurora (launcher requires karma-firefox-launcher plugin) FirefoxAuroraHeadless (launcher requires karma-firefox-launcher plugin) FirefoxNightly (launcher requires karma-firefox-launcher plugin) FirefoxNightlyHeadless (launcher requires karma-firefox-launcher plugin) Opera (launcher requires karma-opera-launcher plugin) Internet Explorer (launcher requires karma-ie-launcher plugin) Safari (launcher requires karma-safari-launcher plugin) A list of browsers to launch and capture. When Karma starts up, it will also start up each browser which is placed within this setting. Once Karma is shut down, it will shut down these browsers as well. You can capture any browser manually by opening the browser and visiting the URL where the Karma web server is listening (by default it is http://localhost:9876/).

property browserSocketTimeout

browserSocketTimeout?: number | undefined;

• Timeout for the client socket connection (in ms) 20000

property captureTimeout

captureTimeout?: number | undefined;

• 60000 Timeout for capturing a browser (in ms). The captureTimeout value represents the maximum boot-up time allowed for a browser to start and connect to Karma. If any browser does not get captured within the timeout, Karma will kill it and try to launch it again and, after three attempts to capture it, Karma will give up.

property client

client?: ClientOptions | undefined;

property colors

colors?: boolean | undefined;

• true Enable or disable colors in the output (reporters and logs).

property concurrency

concurrency?: number | undefined;

• 'Infinity' How many browsers Karma launches in parallel. Especially on services like SauceLabs and Browserstack, it makes sense only to launch a limited amount of browsers at once, and only start more when those have finished. Using this configuration, you can specify how many browsers should be running at once at any given point in time.

property crossOriginAttribute

crossOriginAttribute?: boolean | undefined;

• When true, this will append the crossorigin attribute to generated script tags, which enables better error reporting for JavaScript files served from a different origin true

property customClientContextFile

customClientContextFile?: string | undefined;

• If null (default), uses karma's own client_with_context.html file (which is used when client.runInParent set to true). undefined

property customContextFile

customContextFile?: string | undefined;

• If null (default), uses karma's own context.html file. undefined

property customDebugFile

customDebugFile?: string | undefined;

• If null (default), uses karma's own debug.html file. undefined

property customHeaders

customHeaders?: CustomHeaders[] | undefined;

• Custom HTTP headers that will be set upon serving files by Karma's web server. Custom headers are useful, especially with upcoming browser features like Service Workers. undefined

property customLaunchers

customLaunchers?: { [key: string]: CustomLauncher } | undefined;

property detached

detached?: boolean | undefined;

• When true, this will start the karma server in another process, writing no output to the console. The server can be stopped using the karma stop command. false

property exclude

exclude?: string[] | undefined;

• [] List of files/patterns to exclude from loaded files.

property failOnEmptyTestSuite

failOnEmptyTestSuite?: boolean | undefined;

• Enable or disable failure on running empty test-suites. If disabled the program will return exit-code 0 and display a warning. true

property failOnFailingTestSuite

failOnFailingTestSuite?: boolean | undefined;

• Enable or disable failure on failing tests. true

property failOnSkippedTests

failOnSkippedTests?: boolean | undefined;

• Enable or disable failure on tests deliberately disabled, eg fit() or xit() tests in jasmine. Use this to prevent accidental disabling tests needed to validate production. true

property files

files?: Array<FilePattern | string> | undefined;

• [] List of files/patterns to load in the browser.

property forceJSONP

forceJSONP?: boolean | undefined;

• Force socket.io to use JSONP polling instead of XHR polling false

property formatError

formatError?: ((msg: string) => string) | undefined;

• A new error message line undefined

property frameworks

frameworks?: string[] | undefined;

• [] List of test frameworks you want to use. Typically, you will set this to ['jasmine'], ['mocha'] or ['qunit']... Please note just about all frameworks in Karma require an additional plugin/framework library to be installed (via NPM).

property hostname

hostname?: string | undefined;

• 'localhost' Hostname to be used when capturing browsers.

property httpModule

httpModule?: string | undefined;

• Module used for Karma webserver undefined

property httpsServerOptions

httpsServerOptions?: https.ServerOptions | undefined;

• {} Options object to be used by Node's https class. Object description can be found in the [NodeJS.org API docs](https://nodejs.org/api/tls.html#tls_tls_createserver_options_secureconnectionlistener)

property listenAddress

listenAddress?: string | undefined;

• Address that the server will listen on. Change to 'localhost' to only listen to the loopback, or '::' to listen on all IPv6 interfaces '0.0.0.0' or LISTEN_ADDR

property loggers

loggers?: { [name: string]: Appender } | Appender[] | undefined;

• [{type: 'console'}] A list of log appenders to be used. See the documentation for [log4js] for more information.

property logLevel

logLevel?: string | undefined;

• config.LOG_INFO Possible values: config.LOG_DISABLE config.LOG_ERROR config.LOG_WARN config.LOG_INFO config.LOG_DEBUG Level of logging.

property middleware

middleware?: string[] | undefined;

• [] List of names of additional middleware you want the Karma server to use. Middleware will be used in the order listed. You must have installed the middleware via a plugin/framework (either inline or via NPM). Additional information can be found in [plugins](http://karma-runner.github.io/2.0/config/plugins.html). The plugin must provide an express/connect middleware function (details about this can be found in the [Express](http://expressjs.com/guide/using-middleware.html) docs).

property mime

mime?: { [type: string]: string[] } | undefined;

• {} Redefine default mapping from file extensions to MIME-type. Set property name to required MIME, provide Array of extensions (without dots) as it's value.

property pingTimeout

pingTimeout?: number | undefined;

• Socket.io pingTimeout in ms, https://socket.io/docs/server-api/#new-Server-httpServer-options. Very slow networks may need values up to 60000. Larger values delay discovery of deadlock in tests or browser crashes. 5000

property plugins

plugins?: Array<PluginName | InlinePluginDef> | undefined;

• ['karma-*'] List of plugins to load. A plugin can be a string (in which case it will be required by Karma) or an inlined plugin - Object. By default, Karma loads all sibling NPM modules which have a name starting with karma-*. Note: Just about all plugins in Karma require an additional library to be installed (via NPM).

property port

port?: number | undefined;

• 9876 The port where the web server will be listening.

property preprocessors

preprocessors?: { [name: string]: string | string[] } | undefined;

• {'**/*.coffee': 'coffee'} A map of preprocessors to use.

  Preprocessors can be loaded through [plugins].

  Note: Just about all preprocessors in Karma (other than CoffeeScript and some other defaults) require an additional library to be installed (via NPM).

  Be aware that preprocessors may be transforming the files and file types that are available at run time. For instance, if you are using the "coverage" preprocessor on your source files, if you then attempt to interactively debug your tests, you'll discover that your expected source code is completely changed from what you expected. Because of that, you'll want to engineer this so that your automated builds use the coverage entry in the "reporters" list, but your interactive debugging does not.

property processKillTimeout

processKillTimeout?: number | undefined;

• How long will Karma wait for browser process to terminate before sending a SIGKILL signal 2000

property protocol

protocol?: string | undefined;

• 'http:' Possible Values: http: https: Protocol used for running the Karma webserver. Determines the use of the Node http or https class. Note: Using 'https:' requires you to specify httpsServerOptions.

property proxies

proxies?: PathProxyPairs | undefined;

• {} A map of path-proxy pairs The proxy can be specified directly by the target url or path, or with an object to configure more options

property proxyReq

proxyReq?:
    | ((proxyReq: any, req: any, res: any, options: object) => void)
    | undefined;

• Called when requesting Proxy undefined

property proxyRes

proxyRes?: ((proxyRes: any, req: any, res: any) => void) | undefined;

• Called when respnsing Proxy undefined

property proxyValidateSSL

proxyValidateSSL?: boolean | undefined;

• true Whether or not Karma or any browsers should raise an error when an inavlid SSL certificate is found.

property reporters

reporters?: string[] | undefined;

• ['progress'] Possible Values: dots progress A list of reporters to use. Additional reporters, such as growl, junit, teamcity or coverage can be loaded through plugins. Note: Just about all additional reporters in Karma (other than progress) require an additional library to be installed (via NPM).

property reportSlowerThan

reportSlowerThan?: number | undefined;

• 0 Karma will report all the tests that are slower than given time limit (in ms). This is disabled by default (since the default value is 0).

property restartOnFileChange

restartOnFileChange?: boolean | undefined;

• When Karma is watching the files for changes, it will delay a new run until the current run is finished. Enabling this setting will cancel the current run and start a new run immediately when a change is detected.

property retryLimit

retryLimit?: number | undefined;

• When a browser crashes, karma will try to relaunch. This defines how many times karma should relaunch a browser before giving up. 2

property singleRun

singleRun?: boolean | undefined;

• false Continuous Integration mode. If true, Karma will start and capture all configured browsers, run tests and then exit with an exit code of 0 or 1 depending on whether all tests passed or any tests failed.

property transports

transports?: string[] | undefined;

• ['polling', 'websocket'] An array of allowed transport methods between the browser and testing server. This configuration setting is handed off to [socket.io](http://socket.io/) (which manages the communication between browsers and the testing server).

property upstreamProxy

upstreamProxy?: UpstreamProxy | undefined;

• For use when the Karma server needs to be run behind a proxy that changes the base url, etc

property urlRoot

urlRoot?: string | undefined;

• '/' The base url, where Karma runs. All of Karma's urls get prefixed with the urlRoot. This is helpful when using proxies, as sometimes you might want to proxy a url that is already taken by Karma.

property match

match: string;

• Regular expression string to match files

property name

name: string;

• HTTP header name

property value

value: string;

• HTTP header value

property base

base: string;

property browserName

browserName?: string | undefined;

property flags

flags?: string[] | undefined;

property platform

platform?: string | undefined;

property included

included?: boolean | undefined;

• true Should the files be included in the browser using tag? Use false if you want to load them manually, eg. using Require.js.

property nocache

nocache?: boolean | undefined;

• false Should the files be served from disk on each request by Karma's webserver?

property pattern

pattern: string;

• The pattern to use for matching.

property served

served?: boolean | undefined;

• true Should the files be served by Karma's webserver?

property type

type?: FilePatternTypes | undefined;

• Choose the type to use when including a file 'js' The type determines the mechanism for including the file. The css and html types create link elements; the js and module elements create script elements. The dom type includes the file content in the page, used, for example, to test components combining HTML and JS.

property watched

watched?: boolean | undefined;

• true If autoWatch is true all files that have set watched to true will be watched for changes.

index signature

[path: string]: string | ProxyOptions;

property changeOrigin

changeOrigin?: boolean | undefined;

• Whether or not the proxy should override the Host header using the host from the target false

property target

target: string;

• The target url or path (mandatory)

method run

run: {
    (options?: Config, callback?: ServerCallback): void;
    (options?: ConfigOptions | ConfigFile, callback?: ServerCallback): void;
};

• Deprecated

method stop

stop: {
    (options?: Config, callback?: ServerCallback): void;
    (options?: ConfigOptions, callback?: ServerCallback): void;
};

• This function will signal a running server to stop. The equivalent of karma stop.

• Deprecated

property disconnected

disconnected: boolean;

property error

error: boolean;

property exitCode

exitCode: number;

property failed

failed: number;

property success

success: number;

property hostname

hostname?: string | undefined;

• Will be used as the hostname when launching browsers 'localhost'

property path

path?: string | undefined;

• Will be prepended to the base url when launching browsers and prepended to internal urls as loaded by the browsers '/'

property port

port?: number | undefined;

• Will be used as the port when launching browsers 9875

property protocol

protocol?: string | undefined;

• Will be used as the protocol when launching browsers 'http'

function parseConfig

parseConfig: {
    (configFilePath: string, cliOptions: ConfigOptions): Config;
    (
        configFilePath: string,
        cliOptions: ConfigOptions,
        parseOptions?: ParseOptions & { promiseConfig: true }
    ): Promise<Config>;
    (
        configFilePath: string,
        cliOptions: ConfigOptions,
        parseOptions?: ParseOptions
    ): Config;
};

variable COLOR_PATTERN

const COLOR_PATTERN: string;

• The default color pattern for log output

variable CONSOLE_APPENDER

const CONSOLE_APPENDER: { type: string; layout: { type: string; pattern: string } };

• The default console appender

variable DEFAULT_HOSTNAME

const DEFAULT_HOSTNAME: string;

• The default hostname used for the karma server

variable DEFAULT_LISTEN_ADDR

const DEFAULT_LISTEN_ADDR: string;

• The default listen address used for the karma server

variable DEFAULT_PORT

const DEFAULT_PORT: string | number;

• The default port used for the karma server

variable EXIT_CODE

const EXIT_CODE: string;

• The exit code

variable LOG_DEBUG

const LOG_DEBUG: string;

• The value for the log debug level

variable LOG_DISABLE

const LOG_DISABLE: string;

• The value for disabling logs

variable LOG_ERROR

const LOG_ERROR: string;

• The value for the log error level

variable LOG_INFO

const LOG_INFO: string;

• The value for the log info level

variable LOG_LOG

const LOG_LOG: string;

variable LOG_PRIORITIES

const LOG_PRIORITIES: ['OFF', 'ERROR', 'WARN', 'LOG', 'INFO', 'DEBUG'];

• An array of log levels in descending order, i.e. LOG_DISABLE, LOG_ERROR, LOG_WARN, LOG_LOG, LOG_INFO, and LOG_DEBUG

variable LOG_WARN

const LOG_WARN: string;

• The value for the log warn level

variable NO_COLOR_PATTERN

const NO_COLOR_PATTERN: string;

• The default pattern for log output without color

variable VERSION

const VERSION: string;

• The current version of karma