@types/yeoman-test

construct signature

new (...args: any[]): T;

index signature

[key: string]: T;

property queues

queues: string[];

property answers

answers: Generator.Answers;

• The mocked inquirer-answers.

property args

args: string[];

• The arguments that are passed to the generator.

property dependencies

dependencies: Dependency[];

• A set of generators this generator depends on.

property inDirSet

inDirSet: boolean;

• A value indicating whether a current directory has been set.

property localConfig

localConfig: {};

• The mocked configuration.

property mockedGenerators

mockedGenerators: Dictionary<Generator>;

• A set of mocked generators.

property options

options: {};

• The options that are passed to the generator.

property ran

ran: boolean;

• A value indicating whether the generator ran through.

method async

async: () => () => void;

• Hold the execution until the returned callback is triggered Callback to notify the normal execution can resume

method cd

cd: (dirPath: string) => this;

• Change directory without deleting directory content.

  Parameter dirPath

  Directory path (relative to CWD). Prefer passing an absolute file path for predictable results run context instance

method cleanTestDirectory

cleanTestDirectory: () => void;

• Clean the directory used for tests inside inDir/inTmpDir

method doInDir

doInDir: (cb: (folderPath: string) => void) => this;

• Register an callback to prepare the destination folder.

  Parameter cb

  callback who'll receive the folder path as argument this - run context instance

method inDir

inDir: (dirPath: string, cb?: (folderPath: string) => void) => this;

• Clean the provided directory, then change directory into it

  Parameter dirPath

  Directory path (relative to CWD). Prefer passing an absolute file path for predictable results

  Parameter cb

  callback who'll receive the folder path as argument run context instance

method inTmpDir

inTmpDir: (cb: (folderPath: string) => void) => this;

• Cleanup a temporary directory and change the CWD into it

  This method is called automatically when creating a RunContext. Only use it if you need to use the callback.

  Parameter cb

  callback who'll receive the folder path as argument this - run context instance

method run

run: () => Promise<RunResult>;

• Run the generator on the environment and returns the promise. Promise

method toPromise

toPromise: () => Promise<RunResult>;

• Return a promise representing the generator run process Promise resolved on end or rejected on error

method withArguments

withArguments: (args: string | string[]) => this;

• Provide arguments to the run context

  Parameter args

  command line arguments as Array or space separated string

method withGenerators

withGenerators: (dependencies: Dependency[]) => this;

• Provide dependent generators

  Parameter dependencies

  paths to the generators dependencies

  Example 1

  var angular = new RunContext('../../app'); angular.withGenerators([ '../../common', '../../controller', '../../main', [helpers.createDummyGenerator(), 'testacular:app'] ]); angular.on('end', function () { // assert something });

method withLocalConfig

withLocalConfig: (localConfig: Dictionary<any>) => this;

• Mock the local configuration with the provided config

  Parameter localConfig

  should look just like if called config.getAll()

method withMockedGenerators

withMockedGenerators: (namespaces: string[]) => this;

• Creates mocked generators.

  Parameter namespaces

  The namespaces of the mocked generators.

method withOptions

withOptions: (options: Dictionary<any>) => this;

• Provide options to the run context

  Parameter options

  command line options (e.g. --opt-one=foo)

method withPrompts

withPrompts: (answers: Generator.Answers) => this;

• Mock the prompt with dummy answers

  Parameter answers

  Answers to the prompt questions

construct signature

new (
    Generator: string | Constructor<Generator>,
    settings?: RunContextSettings
): RunContext;

• This class provide a run context object to façade the complexity involved in setting up a generator for testing

  Parameter Generator

  Namespace or generator constructor. If the later is provided, then namespace is assumed to be 'gen:test' in all cases

property namespace

namespace?: string | undefined;

• Namespace (only used if Generator is a constructor) 'gen:test'

property resolved

resolved?: string | undefined;

• File path to the generator (only used if Generator is a constructor)

property tmpdir

tmpdir?: boolean | undefined;

• Automatically run this generator in a tmp dir true

property options

options: RunResultOptions;

• The options of this result.

method assertEqualsFileContent

assertEqualsFileContent: {
    (file: string, expectedContent: string): void;
    (pairs: [string, string][]): void;
};

• Assert that a file's content is the same as the given string

  Parameter file

  path to a file

  Parameter expectedContent

  the expected content of the file

  Parameter pairs

  an array of arrays, where each subarray is a [String, String] pair

  Example 1

  result.assertEqualsFileContent( 'data.js', 'const greeting = "Hello";\nexport default { greeting }' );

  Assert that each file in an array of file-string pairs equals its corresponding string

  Example 2

  result.assertEqualsFileContent([ ['data.js', 'const greeting = "Hello";\nexport default { greeting }'], ['user.js', 'export default {\n name: 'Coleman',\n age: 0\n}'] ]);

method assertFile

assertFile: (path: string | string[]) => void;

• Assert that a file exists

  Parameter path

  path to a file

  Parameter paths

  an array of paths to files

  Example 1

  result.assertFile('templates/user.hbs');

  Assert that each files in the array exists

  Example 2

  result.assertFile(['templates/user.hbs', 'templates/user/edit.hbs']);

method assertFileContent

assertFileContent: {
    (file: string, reg: string | RegExp): void;
    (pairs: [string, string | RegExp][]): void;
};

• Assert that a file's content matches a regex or string

  Parameter file

  path to a file

  Parameter reg

  regex / string that will be used to search the file

  Parameter pairs

  an array of arrays, where each subarray is a [String, RegExp] pair

  Example 1

  result.assertFileContent('models/user.js', /App.User = DS.Model.extend/); result.assertFileContent('models/user.js', 'App.User = DS.Model.extend');

  Assert that each file in an array of file-regex pairs matches its corresponding regex

  Example 2

  var arg = [ [ 'models/user.js', /App.User = DS.Model.extend/ ], [ 'controllers/user.js', /App.UserController = Ember.ObjectController.extend/ ] ] result.assertFileContent(arg);

method assertJsonFileContent

assertJsonFileContent: (
    filename: string,
    content: { [key: string]: any }
) => void;

• Assert a JSON file contains the provided keys

  Parameter filename

  Parameter content

  An object of key/values the file should contains

method assertNoFile

assertNoFile: (file: string | string[]) => void;

• Assert that a file doesn't exist

  Parameter file

  path to a file

  Parameter pairs

  an array of paths to files

  Example 1

  result.assertNoFile('templates/user.hbs');

  Assert that each of an array of files doesn't exist

  Example 2

  result.assertNoFile(['templates/user.hbs', 'templates/user/edit.hbs']);

method assertNoFileContent

assertNoFileContent: {
    (file: string, reg: RegExp | string): void;
    (pairs: [string, string | RegExp][]): void;
};

• Assert that a file's content does not match a regex / string

  Parameter file

  path to a file

  Parameter reg

  regex / string that will be used to search the file

  Parameter pairs

  an array of arrays, where each subarray is a [String, RegExp] pair var arg = [ [ 'models/user.js', /App.User \ DS.Model.extend/ ], [ 'controllers/user.js', /App.UserController = Ember.ObjectController.extend/ ] ] result.assertNoFileContent(arg);

  Example 1

  result.assertNoFileContent('models/user.js', /App.User = DS.Model.extend/); result.assertNoFileContent('models/user.js', 'App.User = DS.Model.extend');

  Assert that each file in an array of file-regex pairs does not match its corresponding regex

method assertNoJsonFileContent

assertNoJsonFileContent: (
    filename: string,
    content: { [key: string]: any }
) => void;

• Assert a JSON file does not contain the provided keys

  Parameter filename

  Parameter content

  An object of key/values the file should not contain

method assertNoObjectContent

assertNoObjectContent: (obj: object, content: { [key: string]: any }) => void;

• Assert an object does not contain the provided keys

  Parameter obj

  Object that should not match the given pattern

  Parameter content

  An object of key/values the object should not contain

method assertObjectContent

assertObjectContent: (obj: object, content: { [key: string]: any }) => void;

• Assert an object contains the provided keys

  Parameter obj

  Object that should match the given pattern

  Parameter content

  An object of key/values the object should contains

method assertTextEqual

assertTextEqual: (value: string, expected: string) => void;

• Assert that two strings are equal after standardization of newlines

  Parameter value

  a string

  Parameter expected

  the expected value of the string

  Example 1

  result.assertTextEqual('I have a yellow cat', 'I have a yellow cat');

method dumpFilenames

dumpFilenames: () => void;

• Dumps the name of each file to the console.

method dumpFiles

dumpFiles: (...files: string[]) => void;

• Either dumps the contents of the specified files or the name and the contents of each file to the console.

method restore

restore: () => this;

• Reverts to old cwd.

  Returns

  this

property cwd

cwd: string;

• The working directory after running the generator.

property env

env: Environment;

• The environment of the generator.

property fs

fs: Editor;

• The file-system editor of the generator.

property memFs

memFs: Store;

• The file-system of the generator.

property mockedGenerators

mockedGenerators: Dictionary<Generator>;

• The mocked generators of the context.

property oldCwd

oldCwd: string;

• The working directory before on running the generator.