tessl/npm-nightwatch
Easy to use Node.js based end-to-end testing solution for web applications using the W3C WebDriver API.
—
Pending
Quality
Pending
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Securityby
Pending
The risk profile of this skill
assertions-expectations.mddocs/
Assertions & Expectations
Comprehensive assertion library supporting both assert-style and expect-style validation patterns for test verification.
Capabilities
Assert-Style Assertions
Traditional assertion methods that throw errors on failure, suitable for immediate validation.
Element Existence Assertions
/**
* Assert element exists in DOM
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.elementPresent(selector: string, message?: string);
/**
* Assert element doesn't exist in DOM
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.elementNotPresent(selector: string, message?: string);Element Visibility Assertions
/**
* Assert element is visible
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.visible(selector: string, message?: string);
/**
* Assert element is hidden
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.hidden(selector: string, message?: string);Element State Assertions
/**
* Assert element is enabled for interaction
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.enabled(selector: string, message?: string);
/**
* Assert element is selected (checkboxes/radio buttons)
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.selected(selector: string, message?: string);Element Attribute & Class Assertions
/**
* Assert element has specific CSS class
* @param selector - Element selector
* @param className - CSS class name
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.hasClass(selector: string, className: string, message?: string);
/**
* Assert element has specific attribute
* @param selector - Element selector
* @param attribute - Attribute name
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.hasAttribute(selector: string, attribute: string, message?: string);
/**
* Assert element has child elements
* @param selector - Element selector
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.hasDescendants(selector: string, message?: string);Text Content Assertions
/**
* Assert element text contains specified string
* @param selector - Element selector
* @param text - Expected text content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.textContains(selector: string, text: string, message?: string);
/**
* Assert element text equals specified string
* @param selector - Element selector
* @param text - Expected text content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.textEquals(selector: string, text: string, message?: string);
/**
* Assert element text matches regular expression
* @param selector - Element selector
* @param regex - Regular expression pattern
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.textMatches(selector: string, regex: RegExp, message?: string);
/**
* Assert element contains specified text (deprecated)
* @param selector - Element selector
* @param text - Expected text content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.containsText(selector: string, text: string, message?: string);Attribute & Property Assertions
/**
* Assert element attribute contains specified value
* @param selector - Element selector
* @param attr - Attribute name
* @param text - Expected attribute content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.attributeContains(selector: string, attr: string, text: string, message?: string);
/**
* Assert element attribute equals specified value
* @param selector - Element selector
* @param attr - Attribute name
* @param value - Expected attribute value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.attributeEquals(selector: string, attr: string, value: string, message?: string);
/**
* Assert element attribute matches regular expression
* @param selector - Element selector
* @param attr - Attribute name
* @param regex - Regular expression pattern
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.attributeMatches(selector: string, attr: string, regex: RegExp, message?: string);
/**
* Assert element CSS property has specified value
* @param selector - Element selector
* @param property - CSS property name
* @param value - Expected property value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.cssProperty(selector: string, property: string, value: string, message?: string);
/**
* Assert DOM property contains specified value
* @param selector - Element selector
* @param prop - Property name
* @param value - Expected property content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.domPropertyContains(selector: string, prop: string, value: any, message?: string);
/**
* Assert DOM property equals specified value
* @param selector - Element selector
* @param prop - Property name
* @param value - Expected property value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.domPropertyEquals(selector: string, prop: string, value: any, message?: string);
/**
* Assert DOM property matches regular expression
* @param selector - Element selector
* @param prop - Property name
* @param regex - Regular expression pattern
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.domPropertyMatches(selector: string, prop: string, regex: RegExp, message?: string);Form Value Assertions
/**
* Assert form element value (deprecated)
* @param selector - Element selector
* @param expected - Expected value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.value(selector: string, expected: string, message?: string);
/**
* Assert element value contains specified text
* @param selector - Element selector
* @param text - Expected value content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.valueContains(selector: string, text: string, message?: string);
/**
* Assert element value equals expected value
* @param selector - Element selector
* @param expected - Expected value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.valueEquals(selector: string, expected: string, message?: string);Page-Level Assertions
/**
* Assert page title (deprecated)
* @param expected - Expected title
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.title(expected: string, message?: string);
/**
* Assert page title contains specified text
* @param expected - Expected title content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.titleContains(expected: string, message?: string);
/**
* Assert page title equals specified text
* @param expected - Expected title
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.titleEquals(expected: string, message?: string);
/**
* Assert page title matches regular expression
* @param regex - Regular expression pattern
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.titleMatches(regex: RegExp, message?: string);
/**
* Assert URL contains specified text
* @param expected - Expected URL content
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.urlContains(expected: string, message?: string);
/**
* Assert URL equals specified text
* @param expected - Expected URL
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.urlEquals(expected: string, message?: string);
/**
* Assert URL matches regular expression
* @param regex - Regular expression pattern
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.urlMatches(regex: RegExp, message?: string);Element Count Assertions
/**
* Assert number of elements matching selector
* @param selector - Element selector
* @param count - Expected element count
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.elementsCount(selector: string, count: number, message?: string);Usage Examples:
// Element existence and visibility
browser.assert.elementPresent("#login-form");
browser.assert.visible("#submit-button");
browser.assert.hidden("#error-message");
// Text content
browser.assert.textContains("#status", "Success");
browser.assert.textEquals("#title", "Welcome");
// Attributes and properties
browser.assert.hasClass("#alert", "error");
browser.assert.attributeEquals("input", "type", "email");
browser.assert.valueContains("#search", "nightwatch");
// Page-level assertions
browser.assert.titleContains("Dashboard");
browser.assert.urlContains("/dashboard");
// Element count
browser.assert.elementsCount(".menu-item", 5);Expect-Style Assertions
Fluent, chainable expectation API providing readable test assertions.
Expect Factory Functions
/**
* Create element expectation for assertions
* @param selector - Element selector
* @returns Element expectation object
*/
browser.expect.element(selector: string): ElementExpectation;
/**
* Create elements collection expectation
* @param selector - Elements selector
* @returns Elements expectation object
*/
browser.expect.elements(selector: string): ElementsExpectation;
/**
* Create page object section expectation
* @param selector - Section selector
* @returns Section expectation object
*/
browser.expect.section(selector: string): SectionExpectation;
/**
* Create component expectation
* @param selector - Component selector
* @returns Component expectation object
*/
browser.expect.component(selector: string): ComponentExpectation;
/**
* Create cookie expectation
* @param name - Cookie name
* @returns Cookie expectation object
*/
browser.expect.cookie(name: string): CookieExpectation;
/**
* Create page title expectation
* @returns Title expectation object
*/
browser.expect.title(): TitleExpectation;
/**
* Create URL expectation
* @returns URL expectation object
*/
browser.expect.url(): UrlExpectation;Element Property Expectations
/**
* Element expectation with chainable properties and methods
*/
interface ElementExpectation {
// Element type/tag expectations
a(type: string): ElementExpectation;
an(type: string): ElementExpectation;
// Attribute expectations
attribute(name: string): AttributeExpectation;
// CSS property expectations
css(property: string): CssExpectation;
// DOM property expectations
property(name: string): PropertyExpectation;
// Content expectations
text: TextExpectation;
value: ValueExpectation;
// State expectations
active: StateExpectation;
enabled: StateExpectation;
present: StateExpectation;
selected: StateExpectation;
visible: StateExpectation;
}Language Chain Properties
/**
* Fluent language chains for readable assertions
*/
interface LanguageChains {
to: ExpectationChain;
be: ExpectationChain;
been: ExpectationChain;
is: ExpectationChain;
that: ExpectationChain;
which: ExpectationChain;
and: ExpectationChain;
has: ExpectationChain;
have: ExpectationChain;
with: ExpectationChain;
at: ExpectationChain;
does: ExpectationChain;
of: ExpectationChain;
same: ExpectationChain;
// Negation chain
not: ExpectationChain;
// Deep equality flag
deep: ExpectationChain;
}Assertion Chain Methods
/**
* Equality assertion methods
* @param value - Expected value
* @returns Promise resolving when assertion passes
*/
equal(value: any): Promise<void>;
equals(value: any): Promise<void>;
eq(value: any): Promise<void>;
/**
* Contains assertion methods
* @param value - Expected contained value
* @returns Promise resolving when assertion passes
*/
include(value: any): Promise<void>;
includes(value: any): Promise<void>;
contain(value: any): Promise<void>;
contains(value: any): Promise<void>;
/**
* Regex match assertion methods
* @param regex - Regular expression pattern
* @returns Promise resolving when assertion passes
*/
match(regex: RegExp): Promise<void>;
matches(regex: RegExp): Promise<void>;
/**
* String start assertion methods
* @param value - Expected start value
* @returns Promise resolving when assertion passes
*/
startWith(value: string): Promise<void>;
startsWith(value: string): Promise<void>;
/**
* String end assertion methods
* @param value - Expected end value
* @returns Promise resolving when assertion passes
*/
endWith(value: string): Promise<void>;
endsWith(value: string): Promise<void>;
/**
* Timeout assertion methods
* @param ms - Timeout in milliseconds
* @returns Promise resolving when assertion passes within timeout
*/
before(ms: number): Promise<void>;
after(ms: number): Promise<void>;Usage Examples:
// Element state expectations
browser.expect.element("#submit-button").to.be.visible;
browser.expect.element("#loading").to.not.be.present;
browser.expect.element("#checkbox").to.be.selected;
// Text content expectations
browser.expect.element("#status").text.to.contain("Success");
browser.expect.element("#title").text.to.equal("Welcome Dashboard");
browser.expect.element("#message").text.to.match(/^Success:/);
// Attribute expectations
browser.expect.element("input").to.have.attribute("type").equals("email");
browser.expect.element("#link").to.have.attribute("href").contains("example.com");
// CSS property expectations
browser.expect.element("#header").to.have.css("background-color").equals("rgb(255, 0, 0)");
browser.expect.element(".hidden").to.have.css("display").equals("none");
// Value expectations
browser.expect.element("#search").to.have.value.that.contains("nightwatch");
browser.expect.element("#email").to.have.value.that.matches(/^[^@]+@[^@]+$/);
// Page-level expectations
browser.expect.title().to.contain("Dashboard");
browser.expect.url().to.match(/\/dashboard$/);
// Cookie expectations
browser.expect.cookie("session_id").to.contain("abc");
// Negation expectations
browser.expect.element("#error").to.not.be.visible;
browser.expect.element("#disabled-button").to.not.be.enabled;
// Chained expectations
browser.expect.element("#form")
.to.be.present.and
.to.be.visible.and
.to.have.attribute("method").equals("POST");Promise-Based Assertions
Handle dynamic content and asynchronous operations.
/**
* Assert promised value meets expectation
* @param promise - Promise resolving to value
* @param expected - Expected value
* @param message - Optional custom message
* @returns Promise resolving when assertion passes
*/
browser.assert.promisedValue(promise: Promise<any>, expected: any, message?: string);Usage Examples:
// Assert on promised values
const titlePromise = browser.getTitle();
browser.assert.promisedValue(titlePromise, "Expected Title");
// Use with async/await
const currentUrl = await browser.getCurrentUrl();
browser.assert.urlEquals(currentUrl, "https://example.com/dashboard");Advanced Expectation Patterns
Complex assertion scenarios and custom validation logic.
Usage Examples:
// Multiple element expectations
browser.expect.elements(".menu-item").count.to.equal(5);
browser.expect.elements(".error").count.to.be.above(0);
// Timeout-based expectations
browser.expect.element("#loading").to.not.be.visible.before(5000);
browser.expect.element("#results").to.be.present.after(2000);
// Conditional expectations
const submitButton = browser.expect.element("#submit");
if (await browser.isVisible("#terms-checkbox")) {
submitButton.to.be.enabled.after(1000);
} else {
submitButton.to.be.enabled;
}
// Custom error messages in expect chains
browser.expect.element("#status")
.text.to.contain("Complete")
.before(10000, "Status should show Complete within 10 seconds");