Docs Help

Terms, Icons, and Labels

Many classes have shortcut names used when creating (instantiating) a class with a configuration object. The shortcut name is referred to as an alias (or xtype if the class extends Ext.Component). The alias/xtype is listed next to the class name of applicable classes for quick reference.

Access Levels

Framework classes or their members may be specified as private or protected. Else, the class / member is public. Public, protected, and private are access descriptors used to convey how and when the class or class member should be used.

Member Types

Member Syntax

Below is an example class member that we can disect to show the syntax of a class member (the lookupComponent method as viewed from the Ext.button.Button class in this case).

lookupComponent ( item ) : Ext.Component
protected

Called when a raw config object is added to this container either during initialization of the items config, or when new items are added), or {@link #insert inserted.

This method converts the passed object into an instanced child component.

This may be overridden in subclasses when special processing needs to be applied to child creation.

Parameters

item :  Object

The config object being added.

Returns
Ext.Component

The component to be added.

Let's look at each part of the member row:

Member Flags

The API documentation uses a number of flags to further commnicate the class member's function and intent. The label may be represented by a text label, an abbreviation, or an icon.

Class Icons

- Indicates a framework class

- A singleton framework class. *See the singleton flag for more information

- A component-type framework class (any class within the Ext JS framework that extends Ext.Component)

- Indicates that the class, member, or guide is new in the currently viewed version

Member Icons

- Indicates a class member of type config

- Indicates a class member of type property

- Indicates a class member of type method

- Indicates a class member of type event

- Indicates a class member of type theme variable

- Indicates a class member of type theme mixin

- Indicates that the class, member, or guide is new in the currently viewed version

Class Member Quick-Nav Menu

Just below the class name on an API doc page is a row of buttons corresponding to the types of members owned by the current class. Each button shows a count of members by type (this count is updated as filters are applied). Clicking the button will navigate you to that member section. Hovering over the member-type button will reveal a popup menu of all members of that type for quick navigation.

Getter and Setter Methods

Getting and setter methods that correlate to a class config option will show up in the methods section as well as in the configs section of both the API doc and the member-type menus just beneath the config they work with. The getter and setter method documentation will be found in the config row for easy reference.

History Bar

Your page history is kept in localstorage and displayed (using the available real estate) just below the top title bar. By default, the only search results shown are the pages matching the product / version you're currently viewing. You can expand what is displayed by clicking on the button on the right-hand side of the history bar and choosing the "All" radio option. This will show all recent pages in the history bar for all products / versions.

Within the history config menu you will also see a listing of your recent page visits. The results are filtered by the "Current Product / Version" and "All" radio options. Clicking on the button will clear the history bar as well as the history kept in local storage.

If "All" is selected in the history config menu the checkbox option for "Show product details in the history bar" will be enabled. When checked, the product/version for each historic page will show alongside the page name in the history bar. Hovering the cursor over the page names in the history bar will also show the product/version as a tooltip.

Search and Filters

Both API docs and guides can be searched for using the search field at the top of the page.

On API doc pages there is also a filter input field that filters the member rows using the filter string. In addition to filtering by string you can filter the class members by access level, inheritance, and read only. This is done using the checkboxes at the top of the page.

The checkbox at the bottom of the API class navigation tree filters the class list to include or exclude private classes.

Clicking on an empty search field will show your last 10 searches for quick navigation.

API Doc Class Metadata

Each API doc page (with the exception of Javascript primitives pages) has a menu view of metadata relating to that class. This metadata view will have one or more of the following:

Expanding and Collapsing Examples and Class Members

Runnable examples (Fiddles) are expanded on a page by default. You can collapse and expand example code blocks individually using the arrow on the top-left of the code block. You can also toggle the collapse state of all examples using the toggle button on the top-right of the page. The toggle-all state will be remembered between page loads.

Class members are collapsed on a page by default. You can expand and collapse members using the arrow icon on the left of the member row or globally using the expand / collapse all toggle button top-right.

Desktop -vs- Mobile View

Viewing the docs on narrower screens or browsers will result in a view optimized for a smaller form factor. The primary differences between the desktop and "mobile" view are:

Viewing the Class Source

The class source can be viewed by clicking on the class name at the top of an API doc page. The source for class members can be viewed by clicking on the "view source" link on the right-hand side of the member row.

Sencha Test 2.2.1


top

ST singleton

Hierarchy

ST

Summary

This is the root namespace for the Sencha Test API.

A good place to start reading about the API is ST.future.Element which explains some basics about how to use the API and has examples. Also see ST.future.Component for details on interacting with Ext components.

No members found using the current filters

properties

Instance Properties

chromeVersion : Number
readonly ro

The current version of Chrome (0 if the browser is not Chrome).

firefoxVersion : Number
readonly ro

The current version of Firefox (0 if the browser is not Firefox).

ieVersion : Number
readonly ro

The current version of IE (0 if the browser is not IE). This does not account for the documentMode of the current page, which is factored into isIE8, and isIE9. Thus this is not always true:

ST.isIE8 == (ST.ieVersion == 8)

isChrome : Boolean
readonly ro

True if the detected browser is Chrome.

isGecko : Boolean
readonly ro

True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).

isIE : Boolean
readonly ro

True if the detected browser is Internet Explorer.

isIE10 : Boolean
readonly ro

True if the detected browser is Internet Explorer 10.x.

isIE10m : Boolean
readonly ro

True if the detected browser is Internet Explorer 10.x or lower.

isIE10p : Boolean
readonly ro

True if the detected browser is Internet Explorer 10.x or higher.

isIE11 : Boolean
readonly ro

True if the detected browser is Internet Explorer 11.x.

isIE11m : Boolean
readonly ro

True if the detected browser is Internet Explorer 11.x or lower.

isIE11p : Boolean
readonly ro

True if the detected browser is Internet Explorer 11.x or higher.

isIE8 : Boolean
readonly ro

True if the detected browser is Internet Explorer 8.x.

isIE8m : Boolean
readonly ro

True if the detected browser is Internet Explorer 8.x or lower.

isIE8p : Boolean
readonly ro

True if the detected browser is Internet Explorer 8.x or higher.

isIE9 : Boolean
readonly ro

True if the detected browser is Internet Explorer 9.x.

isIE9m : Boolean
readonly ro

True if the detected browser is Internet Explorer 9.x or lower.

isIE9p : Boolean
readonly ro

True if the detected browser is Internet Explorer 9.x or higher.

isLinux : Boolean
readonly ro

True if the detected platform is Linux.

isMac : Boolean
readonly ro

True if the detected platform is Mac OS.

isOpera : Boolean
readonly ro

True if the detected browser is Opera.

isSafari : Boolean
readonly ro

True if the detected browser is Safari.

isStrict : Boolean

true if browser is using strict mode.

Defaults to:

document.compatMode === "CSS1Compat"

isWebKit : Boolean
readonly ro

True if the detected browser uses WebKit.

isWindows : Boolean
readonly ro

True if the detected platform is Windows.

operaVersion : Number
readonly ro

The current version of Opera (0 if the browser is not Opera).

ready : ST.Gate
readonly ro private pri

The ready gate is opened when the document is ready as well as Ext JS / Sencha Touch.

Defaults to:

new ST.Gate('ready')

Available since: 1.0.2

safariVersion : Number
readonly ro

The current version of Safari (0 if the browser is not Safari).

testsReady : ST.Gate
readonly ro private pri

The testsReady gate is opened when all tests are described and ready to run.

Defaults to:

new ST.Gate('testsReady', 50)

Available since: 1.0.2

webKitVersion : Number
readonly ro

The current version of WebKit (0 if the browser does not use WebKit).

methods

Instance Methods

absent ( locator, [timeout] ) : ST.future.Element
chainable ch

Schedules a wait for an element to be absent or missing from the DOM. This is typically used after some future action that should cause a removal.

 ST.button('@okButton').click();
 ST.absent('@confirmationWindow'); // the window owning the OK button

This method is similar to ST.future.Element#removed but the difference is that this method does not first wait for the specified element to be found. This difference makes this method suitable for checking for things that should not be present in the first place.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the element to be removed.

Returns

:ST.future.Element

addController ( controller )
private pri

Add controller

Parameters

controller :  Object

addGlobals ( add )

Adds one or more allowable global variable names. Variable names can be simple names or a regex.

Parameters

add :  String/String[]

addLocatorStrategy ( strategy )

Registers a locator strategy for recording target locators. A locator strategy implements a locate method. If the locator parameter is a function, it is treated as an implementation of such a method.

For example:

 ST.addLocatorStrategy(function (el, targets) {
     if (el.id) {
         targets.push('>> #' + el.id);
     }
 });

The above locator strategy is not very useful, but illustrates the process of adding new strategies.

Parameters

strategy :  ST.locator.Strategy/Function

afterFile ( file )
private pri

Called after a test file is loaded

Parameters

file :  Object

afterFiles
private pri

Called after test files are loaded

alert ( config ) : ST.Alert

Creates and returns an ST.Alert passing along the specified config object. This method calls ST.Alert#show before returning the instance.

Parameters

config :  Object

The config object for an instance of ST.Alert.

Returns

:ST.Alert

apply ( object, config, [own] ) : Object

Copies all the properties of config to the specified object.

 ST.apply(obj = {}, { a: 1 });
 // obj.a === 1

Parameters

object :  Object

The receiver of the properties.

config :  Object

The primary source of the properties.

own :  Boolean (optional)

Pass true to limit the copy to hasOwnProperty properties of the config object.

Returns

:Object

returns object.

applyIf ( object, config, [own] ) : Object

Copies all the properties of config to object if they don't already exist.

Parameters

object :  Object

The receiver of the properties

config :  Object

The source of the properties

own :  Boolean (optional)

Pass true to limit the copy to hasOwnProperty properties of the config object.

Returns

:Object

returns obj

beforeFile ( file )
private pri

Called before a test file is loaded

Parameters

file :  Object

beforeFiles
private pri

Called before test files are loaded

button ( locator, [timeout] ) : ST.future.Button

Returns a ST.future.Button used to queue operations for when that button becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the button.

Returns

:ST.future.Button

capitalize ( string ) : String

Capitalize the first letter of the given string.

Parameters

string :  String

Returns

:String

chain ( object )

Returns a new object with the given object as the prototype chain. This method is designed to mimic the ECMA standard Object.create method and is assigned to that function when it is available.

NOTE This method does not support the property definitions capability of the Object.create method. Only the first argument is supported.

Parameters

object :  Object

The prototype chain for the new object.

checkBox ( locator, [timeout] ) : ST.future.CheckBox

Returns a ST.future.CheckBox used to queue operations for when that component becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the component.

Returns

:ST.future.CheckBox

classFromString ( name )
private pri

Returns the class associated with the passed class name

Parameters

name :  String

The name of the class to retrieve

comboBox ( locator, [timeout] ) : ST.future.ComboBox

Returns a ST.future.ComboBox used to queue operations for when that Ext.form.field.ComboBox becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the combobox.

Returns

:ST.future.ComboBox

component ( locator, [timeout] ) : ST.future.Component

Returns a ST.future.Component used to queue operations for when that component becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the component.

Returns

:ST.future.Component

configureContext ( cfg )

Configures a custom context. Configured methods can return promises if they perform asynchronous operations.

Parameters

cfg :  Object

Configuration object. Can contain the following properties:

init :  Function (optional)

Context initialization function

stop :  Function (optional)

Context termination function

constructor ( fn, [timeout] )
protected pro

Parameters

fn :  Function/Object

The user function or a config object to apply to this instance. The config object must contain an fn property with the user function.

timeout :  Number (optional)

The timeout for fn to complete. If not specified, the default timeout is used.

dataView ( locator, [timeout] ) : ST.future.DataView

Returns a ST.future.DataView used to queue operations for when that Ext.view.View becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the dataview.

Returns

:ST.future.DataView

decapitalize ( string ) : String

Lower-cases the first letter of the given string.

Parameters

string :  String

Returns

:String

defer ( fn, [scope], delay )

Similar to setTimeout and Ext.defer this method schedules a call to the given method after the given delay and returns an id that can be used to cancel the request.

To cancel a timeout, call ST#deferCancel. Do not pass these id's to the DOM.

Note

In some modern browsers (currently FF and Chrome timeouts are clamped to >= 1000ms for inactive tabs. https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout#Timeouts_in_inactive_tabs_clamped_to_>1000ms

This can result in much larger delays than expected when playing back recorded events since the Event Player is not guaranteed to be run in an active tab/window.

This class leverages Web Workers to emulate the browser's setTimeout and setInterval functionality without the undesirable clamping in incative tabs.

Falls back to window.setTimeout/setInterval where Web Workers are not available.

Parameters

fn :  Function

The function to call after delay milliseconds.

scope :  Object (optional)

The this pointer to use for calling fn.

delay :  Number

The number of milliseconds to delay before calling fn.

deferCancel ( id )

Cancels an operation requested using ST#defer.

Parameters

id :  Object

define ( data, [onComplete] ) : Function

Defines a primitive class similar to the Ext JS class system. The following features are provided:

  • extend
  • singleton
  • statics (like ES6, all statics are inherited)

Parameters

data :  Object/Function

The class body or a method that will return the class body. The method is passed the class constructor as its single argument.

onComplete :  Function (optional)

Optional completion method. Since this method is synchronous, onComplete is called immediately.

Returns

:Function

The class constructor

documentReady ( state, timeout ) : ST.future.Element

Waits for the document.readyState to be the specified state.

Parameters

state :  String

Defaults to: "complete"

timeout :  Object

Returns

:ST.future.Element

this

each ( iterable, fn, [scope], [reverse] ) : Boolean

Iterates an array or an iterable value and invoke the given callback function for each item.

var countries = ['Vietnam', 'Singapore', 'United States', 'Russia'];

ST.each(countries, function(name, index, countriesItSelf) {
    console.log(name);
});

var sum = function() {
    var sum = 0;

    ST.each(arguments, function(value) {
        sum += value;
    });

    return sum;
};

sum(1, 2, 3); // returns 6

The iteration can be stopped by returning false from the callback function. Returning undefined (i.e return;) will only exit the callback function and proceed with the next iteration of the loop.

ST.each(countries, function(name, index, countriesItSelf) {
    if (name === 'Singapore') {
        return false; // break here
    }
});

Parameters

iterable :  Array/NodeList

The value to be iterated. TODO this fn param doc renders strange.... Function< /a>

fn :  Function

The callback function. If it returns false, the iteration stops and this method returns the current index. Returning undefined (i.e return;) will only exit the callback function and proceed with the next iteration in the loop.

item :  Object

The item at the current index in the passed array

index :  Number

The current index within the array

allItems :  Array

The array itself which was passed as the first argument

return :  Boolean

Return false to stop iteration.

scope :  Object (optional)

The scope (this reference) in which the specified function is executed.

reverse :  Boolean (optional)

Reverse the iteration order (loop from the end to the beginning).

Defaults to: false

Returns

:Boolean

If no iteration returns false then this method returns true. Otherwise this method returns the index that returned false. See description for the fn parameter.

element ( locator, timeout ) : ST.future.Element

Returns a ST.future.Element used to queue operations for when that element becomes available (rendered to the page). The element does not need to be visible for this future to complete.

Once a future is returned from this method, it is typically used to describe some sequence of actions, wait for state transitions and perform inspections.

 ST.element('@someEl').
     click(10, 10).
     textLike(/hello/i).
     and(function (el) { ... });

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Object

Returns

:ST.future.Element

execute ( fn ) : ST.future.Element

Executes the provided function in the browser under test. Be aware that with WebDriver scenarios the scope of the function is not related to the scope of the test code. The following will not work:

 var foo = '1';
 ST.execute(function () {
     expect(foo).toBe(1);
 });

Because the bar foo is in the test scope but the function is executed in the browser under test.

For in-browser scenarios the code above will work.

If the provided function returns a value it will be set on the current future's data as the property 'executeResult'.

 ST.element('@some-div')
     .execute(function () {
         return 'foo';
     })
     .and(function (future) {
         expect(future.data.executeResult).toBe('foo')
     });

Similarly if any errors are thrown in the provided function the error will be set on the future's data as the property 'executeError'.

 ST.element('@some-div')
     .execute(function () {
         throw 'foo';
     })
     .and(function (future) {
         expect(future.data.executeError).toBe('foo')
     });

For the function, the 1st argument will be the future value such as ST.Element or an Ext.Component or the future itself in the case of WebDriver scenarios. The scope of functions will be the playable event itself. To access the future use this.future.

Parameters

fn :  Function

the function to execute in the browser under test

Returns

:ST.future.Element

this

expectFailure ( [match] )

Help write negative test cases by passing when some or all of the test results are failures.

This function can be used in a fluent chain or by itself. It schedules a check on the test results so far so can generally be used inside the test unless the test itself is expected to timeout, then it should be used in an afterEach function.

When called with no parameters all test results which are failures will be marked as passing and have 'Expected Failure: ' prepended to their message.

 describe('failures', function () {
     it('should pass', function () {
         expect(1).toBe(2);
         ST.expectFailure();
     });
 });

 describe('no failures', function () {
     it('should pass', function () {
         expect(1).toBe(1);
         ST.expectFailure();
     });
 });

Will result in the following messages:

 Expected failure: Expected 1 to be 2.
 Expected at least one failing result but found none.

It is also possible to specify one or more String or RegExp items to match errors specifically.

 describe('match string and regexes', function () {
     it('expects failure', function () {
         expect(1).toBe(1);
         expect(1).toBe(2);
         expect('foo').toBe('bar');
         ST.expectFailure([
             /.*foo.*bar/,
             'Expected 1 to be 2'
         ]);
     });
 });

Would result in three passing results for the test:

 Expected 1 to be 1.
 Expected failure: Expected 'foo' to be 'bar'.
 Expected failure: Expected 1 to be 2.

One special case where you would need to use ST.expectFailure in an afterEach is when the test case you are expecting a failure in times out. For futures that timeout you can use the ST.future.Element#timedout method.actions

 describe('suite', function () {
    it('should timeout the entire test', function () {
         ST.element().and(
             500,
             function (el,done) {
                 setTimeout(function () {
                     done();
                 },1000); // force a timeout
             }
         );
     });

     afterEach(function () {
         ST.expectFailure();
     });
 });

Available since: 2.0.0

Parameters

match :  String/RegExp/String[]/RegExp[] (optional)

Optional set of messages to match

expectFailure ( match )

Parameters

match :  Object

field ( locator, [timeout] ) : ST.future.Field

Returns a ST.future.Field used to queue operations for when that component becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the component.

Returns

:ST.future.Field

find ( target, [wrap], [root], [direction] ) : ST.Element

Given the target locator string, return the matching element or null if one is not found. See ST.Locator for a description of valid locator strings.

Alias for ST.Locator#find.

Parameters

target :  String

The target locator string.

wrap :  Boolean (optional)

Pass true to return a wrapped ST.Element instead of the raw DOM node.

Defaults to: false

root :  HTMLElement/ST.Element/Ext.Component (optional)

direction :  "down"/"up"/"child" (optional)

Defaults to: "down"

Returns

:ST.Element

fly ( domNode, [flyName] ) : ST.Element

Given one of the various ways to identify a DOM node, this method returns a temporary, fly-weight ST.Element or null. Instances returned by this method should be used briefly to call the methods of the ST.Element and then ignored since the instance will be re-used by future calls to this method.

Parameters

domNode :  String/HTMLElement/ST.Element/Ext.Element

flyName :  String (optional)

An optional name for the fly. Passing a custom name can be used to control the scope of re-use of the returned instance.

Defaults to: "fly"

Returns

:ST.Element

get ( domNode ) : ST.Element

Given one of the various ways to identify a DOM node, this method returns a temporary, fly-weight ST.Element or null. Each call to this method returns a new ST.Element instance. Unlike Ext.get() this method does not maintain an element cache nor does it assign an id to the element. In other words, this method is equivalent to new ST.Element().

Parameters

domNode :  String/HTMLElement/ST.Element/Ext.Element

Returns

:ST.Element

getDom ( domNode ) : HTMLElement

Given one of the various ways to identify a DOM node, this method returns the DOM node or null.

Parameters

domNode :  String/HTMLElement/ST.Element/Ext.Element

Returns

:HTMLElement

getKey ( object, value )
private pri

Returns the first matching key corresponding to the given value. If no matching value is found, null is returned.

Parameters

object :  Object

value :  Object

The value to find

getUrl ( callback ) : ST.future.Element

Returns the current url of the target browser as the first arg of the provided callback function.

ST.navigate('https://duckduckgo.com') .getUrl(function (url) { expect(url).toContain('duckduckgo'); });

Parameters

callback :  Function

The callback function to execute when the url has been determined

Returns

:ST.future.Element

this

getValues ( object ) : Array
private pri

Gets all values of the given object as an array.

Parameters

object :  Object

Returns

:Array

An array of values from the object

grid ( locator, [timeout] ) : ST.future.Grid

Returns a ST.future.Grid used to queue operations for when that Ext.grid.Panel becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the dataview.

Returns

:ST.future.Grid

log ( message )
private pri

Log

Parameters

message :  Object

navigate ( url ) : ST.future.Element

Causes the browser to load the specified URL.

 ST.navigate('https://www.google.com')
     .input('input[title="Search"]').
     .navigate('https://www.sencha.com')
     .input('input');

NOTE: Using this method to navigate away from the page in a non-WebDriver test will halt the test execution. It is possible to use this to navigate to different anchors on the same page:

 ST.getUrl(function (url) {
     ST.navigate(url+'#first-anchor').
         element('@some-div');

});

If URL begins with '#' then the page will be redirected to that anchor.

Parameters

url :  String

The URL to navigate to.

Returns

:ST.future.Element

this

onPlayerError ( ex )
private pri

Called when the Player throws an error

Parameters

ex :  Object

onReady ( fn )
private pri

This method queues a function to be called when ST is ready to run.

Parameters

fn :  Function

panel ( locator, [timeout] ) : ST.future.Panel

Returns a ST.future.Panel used to queue operations for when that panel becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the panel.

Returns

:ST.future.Panel

picker ( locator, [timeout] ) : ST.future.Picker

Returns a ST.future.Picker used to queue operations for when that Ext.form.field.Picker becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the picker.

Returns

:ST.future.Picker

play ( events, [done], [future] ) : ST.playable.Playable[]

Adds an array of events to the queue and optionally calls a done method when the events have all been played.

Parameters

events :  ST.playable.Playable[]

The events to play.

done :  Function (optional)

Optional function to call after the events have played.

future :  Object (optional)

Optional ST.future.Element to associate with these events. // TODO what if an event changes the future??? :( How funny sounding...

Returns

:ST.playable.Playable[]

The events array with each element now promoted from config object to ST.playable.Playable instance.

player ST.event.Player

Lazily creates and returns the shared ST.event.Player. This is rarely called directly, but is the underlying mechanism used the inject events using the ST#play and ST.future.Element API's.

Returns

:ST.event.Player

prettyPrint ( value )
private pri

Pretty print

Parameters

value :  Object

screenshot ( name, done )

Takes a snapshot of the viewport and compares it to the associated baseline image.

Parameters

name :  String

done :  Function

screenshot ( name, callback, tolerance, timeout ) : ST.future.Element

Takes a snapshot of the viewport and compares it to the associated baseline image.

 ST.element('@someEl').
     click(10, 10).
     screenshot();

Can also be used directly from the ST namespace and chained with other futures API methods:

 ST.screenshot('first', 10, 10000).    // tolerance=10 (10 pixels), timeout=10000 (10 seconds)
     navigate('#somewhere').
     screenshot('second', 20);        // tolerance=20 (20 pixels), timeout=30000 (default)

It is possible to set the maximum number of different pixels the current snapshot can have compared to the baseline image before the method will cause the test to fail, by defining a tolerance:

 ST.screenshot('first', 200);    // Tolerance of 200 pixels (defaults to 0 if not explicitly set)

To support the 1.0.x API as well as for flexibility the second parameter can be a callback function, though the preferred usage is chaining as above.

 ST.screenshot('third', function () {
     // the screenshot has been taken!
 });

Parameters

name :  String

for the snapshot filename. Default is an incremental number for the current test run.

callback :  Object

tolerance :  Object

timeout :  Object

Returns

:ST.future.Element

this

select ( locator, [timeout] ) : ST.future.Select

Returns a ST.future.Select used to queue operations for when that Ext.field.Select becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the select field.

Returns

:ST.future.Select

sendMessage ( message, callback )
private pri

Send message

Parameters

message :  Object

callback :  Object

setLocatorStrategies ( strategy )

Replaces the locator strategies with those provided to this call. For details on locator strategy see addLocatorStrategy.

The following call would produce the default strategies:

 ST.setLocatorStrategies(
     new ST.locator.Strategy()
 );

This method is used to control the presence and order of locator strategies. The order is important to the ST.event.Recorder because the first locator strategy to produce an element locator determines the default event target and/or relatedTarget.

Parameters

strategy :  ST.locator.Strategy/Function

setViewportSize ( width, height ) : ST.future.Element

Sets the size of the browser viewport. This method has no effect on in-browser tests when the browser wasn't launched via WebDriver, and it is particulary useful to ensure that compared screenshots have the same dimensions.

ST.setViewportSize(1024, 768)
  .screenshot();

Parameters

width :  Number

height :  Object

Returns

:ST.future.Element

this

slider ( locator, [timeout] ) : ST.future.Slider

Returns a ST.future.Slider used to queue operations for when that component becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the component.

Returns

:ST.future.Slider

startRecording ( config, done )

Starts the ST.event.Recorder. Once this method is called all further test execution is halted.

This method is typically injected automatically by Sencha Test Studio when using its Event Recorder and is therefore rarely called directly.

Parameters

config :  Object

Options to configure the ST.event.Recorder.

done :  Object

startRecording

Starts the ST.event.Recorder. Once this method is called all further test execution is halted.

This method is typically injected automatically by Sencha Test Studio when using its Event Recorder and is therefore rarely called directly.

startRecording

Starts the ST.event.Recorder. Once this method is called all further test execution is halted.

This method is typically injected automatically by Sencha Test Studio when using its Event Recorder and is therefore rarely called directly.

table ( locator, [timeout] ) : ST.future.Table

Returns a ST.future.Table used to queue operations for when that HTML table element becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the dataview.

Returns

:ST.future.Table

textField ( locator, [timeout] ) : ST.future.TextField

Returns a ST.future.TextField used to queue operations for when that component becomes available.

Parameters

locator :  String

See ST.Locator for supported syntax.

timeout :  Number (optional)

The maximum time (in milliseconds) to wait for the component.

Returns

:ST.future.TextField

timeout ( fn, [scope], [millisec] ) : Function
private pri

Similar setTimeout but instead returns a function that cancels the timer.

The timeout value (millisec) defaults to ST.options.timeout unless that value is set to 0 in which case timeouts are disabled. In that case, fn will never be called.

Parameters

fn :  Function

The function to call after millisec milliseconds.

scope :  Object (optional)

The this pointer to use for calling fn.

millisec :  Number (optional)

The delay in milliseconds. Defaults to ST.options.timeout and is disabled if that value is 0.

Returns

:Function

wait ST.future.Element

Returns a limited-use ST.future.Element that can be used only to wait and perform some manual steps.

Returns

:ST.future.Element

Sencha Test 2.2.1