@cepharum/contextual-gherkin 3.0.0-beta.5 → 3.0.0

package/steps/global-action.js

@@ -1,108 +1,36 @@
 import { When } from "@cucumber/cucumber";
-import { Api } from "../index.js";
-
-export const actAndTrack = async( cardinal, matches, action, input ) => {
-	const api = Api.access();
-	const target = matches.find( "$" + action, false );
-
-	await api.expect( target.locator, `none or multiple matching $${action} target for selected ${cardinal.word} to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	// detach matches first as interacting with them might change them in a way
-	// so that the original query isn't finding them anymore (e.g. changing
-	// label of a button on click)
-	const detached = await matches.detach( cardinal.cardinality );
-
-	if ( input == null ) {
-		await target.actions[action]();
-	} else {
-		await target.actions.fill( input );
-	}
-
-	await detached.track( cardinal.word, cardinal.cardinality );
-
-	const wait = Number( process.env.ACTION_WAIT ) || 100;
-	if ( wait > 0 ) {
-		await api.wait( wait );
-	}
-};
+import {
+	globalActionByAttribute,
+	globalActionByClass,
+	globalActionByLabel,
+	globalActionByProperty, globalActionByTextContent
+} from "../lib/step-helper.js";
 
 When( "I click (on ){cardinal-word} with ID/id {text-or-regexp}", ( cardinal, id ) => globalActionByAttribute( cardinal, "id", id, "click" ) );
 When( "I click (on ){cardinal-word} with name {text-or-regexp}", ( cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "click" ) );
 When( "I click (on ){cardinal-word} named {text-or-regexp}", ( cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "click" ) );
+When( "I click (on ){cardinal-word} with icon {text-or-regexp}", ( cardinal, icon ) => globalActionByAttribute( cardinal, "icon", icon, "click" ) );
 
 When( "I hover (over ){cardinal-word} with ID/id {text-or-regexp}", ( cardinal, id ) => globalActionByAttribute( cardinal, "id", id, "hover" ) );
 When( "I hover (over ){cardinal-word} with name {text-or-regexp}", ( cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "hover" ) );
 When( "I hover (over ){cardinal-word} named {text-or-regexp}", ( cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "hover" ) );
+When( "I hover (over ){cardinal-word} with icon {text-or-regexp}", ( cardinal, icon ) => globalActionByAttribute( cardinal, "icon", icon, "hover" ) );
 
 When( "I enter {string-or-word} into {cardinal-word} with ID/id {text-or-regexp}", ( input, cardinal, id ) => globalActionByAttribute( cardinal, "id", id, "enter", input ) );
 When( "I enter {string-or-word} into {cardinal-word} with name {text-or-regexp}", ( input, cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "enter", input ) );
 When( "I enter {string-or-word} into {cardinal-word} named {text-or-regexp}", ( input, cardinal, name ) => globalActionByAttribute( cardinal, "name", name, "enter", input ) );
+When( "I enter {string-or-word} into {cardinal-word} with icon {text-or-regexp}", ( input, cardinal, icon ) => globalActionByAttribute( cardinal, "icon", icon, "enter", input ) );
+
+
+When( "I click (on ){cardinal-word} marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, false, "click" ) );
+When( "I click (on ){cardinal-word} not marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, true, "click" ) );
+
+When( "I hover (over ){cardinal-word} marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, false, "hover" ) );
+When( "I hover (over ){cardinal-word} not marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, true, "hover" ) );
+
+When( "I enter {string-or-word} into {cardinal-word} marked/tagged as {word}", ( input, cardinal, className ) => globalActionByClass( cardinal, className, false, "enter", input ) );
+When( "I enter {string-or-word} into {cardinal-word} not marked/tagged as {word}", ( input, cardinal, className ) => globalActionByClass( cardinal, className, true, "enter", input ) );
 
-/**
- * Searches for element matching a named attribute by value and performs
- * selected action on it.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string|RegExp} name name of attribute to match
- * @param {string|RegExp} value value of named attribute to match
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @return {Promise<void>} promises step passed
- */
-export async function globalActionByAttribute( cardinal, name, value, action, input ) {
-	const api = Api.access();
-
-	if ( cardinal.cardinality !== "singular" ) {
-		await api.expect( false, `selector is not addressing a single ${cardinal.word} to ${input == null ? action : `enter '${input}' into`}` )
-			.toEqual( true );
-	}
-
-	const matches = api.find( cardinal.word ).withAttribute( name, value );
-
-	await api.expect( matches.locator, `no single matching ${cardinal.word} with attribute ${name} == "${value}" to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	await actAndTrack( cardinal, matches, action, input );
-}
-
-When( "I click (on ){cardinal-word} marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, "click", false ) );
-When( "I click (on ){cardinal-word} not marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, "click", true ) );
-
-When( "I hover (over ){cardinal-word} marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, "hover", false ) );
-When( "I hover (over ){cardinal-word} not marked/tagged as {word}", ( cardinal, className ) => globalActionByClass( cardinal, className, "hover", true ) );
-
-When( "I enter {string-or-word} into {cardinal-word} marked/tagged as {word}", ( input, cardinal, className ) => globalActionByClass( cardinal, className, "enter", false, input ) );
-When( "I enter {string-or-word} into {cardinal-word} not marked/tagged as {word}", ( input, cardinal, className ) => globalActionByClass( cardinal, className, "enter", true, input ) );
-
-/**
- * Searches for element matching a named attribute by value and performs
- * selected action on it.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string|RegExp} className class required for match
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {boolean} negated inverts the assertion by means of requiring one or all elements of context not to have selected class
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @return {Promise<void>} promises step passed
- */
-export async function globalActionByClass( cardinal, className, action, negated, input ) {
-	const api = Api.access();
-
-	if ( cardinal.cardinality !== "singular" ) {
-		await api.expect( false, `selector is not addressing a single ${cardinal.word} ${negated ? "not " : ""}marked as ${className} to ${input == null ? action : `enter '${input}' into`}` )
-			.toEqual( true );
-	}
-
-	const matches = api
-		.find( cardinal.word )
-		.withListProperty( "classList", className, negated );
-
-	await api.expect( matches.locator, `no single matching ${cardinal.word} ${negated ? "not " : ""}marked as ${className} to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	await actAndTrack( cardinal, matches, action, input );
-}
 
 When( "I click (on ){cardinal-word} with value {text-or-regexp}", ( cardinal, value ) => globalActionByProperty( cardinal, "value", value, "click" ) );
 
@@ -110,32 +38,6 @@ When( "I hover (over ){cardinal-word} with value {text-or-regexp}", ( cardinal,
 
 When( "I enter {string-or-word} into {cardinal-word} with value {text-or-regexp}", ( input, cardinal, value ) => globalActionByProperty( cardinal, "value", value, "enter", input ) );
 
-/**
- * Searches for element matching a named DOM property by value and performs
- * selected action on it.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string|RegExp} name name of attribute to match
- * @param {string|RegExp} value value of named attribute to match
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @return {Promise<void>} promises step passed
- */
-export async function globalActionByProperty( cardinal, name, value, action, input ) {
-	const api = Api.access();
-
-	if ( cardinal.cardinality !== "singular" ) {
-		await api.expect( false, `selector is not addressing a single ${cardinal.word} with property ${name} == "${value}" to ${input == null ? action : `enter '${input}' into`}` )
-			.toEqual( true );
-	}
-
-	const matches = api.find( cardinal.word ).withProperty( name, value );
-
-	await api.expect( matches.locator, `no single matching ${cardinal.word} with property ${name} == "${value}" to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	await actAndTrack( cardinal, matches, action, input );
-}
 
 When( "I click (on ){cardinal-word} with label {text-or-regexp}", ( cardinal, label ) => globalActionByLabel( cardinal, label, false, "click" ) );
 When( "I click (on ){cardinal-word} with partial label {text-or-regexp}", ( cardinal, label ) => globalActionByLabel( cardinal, label, true, "click" ) );
@@ -152,32 +54,6 @@ When( "I enter {string-or-word} into {cardinal-word} with partial label {text-or
 When( "I enter {string-or-word} into {cardinal-word} labelled with {text-or-regexp}", ( input, cardinal, label ) => globalActionByLabel( cardinal, label, false, "enter", input ) );
 When( "I enter {string-or-word} into {cardinal-word} partially labelled with {text-or-regexp}", ( input, cardinal, label ) => globalActionByLabel( cardinal, label, false, "enter", input ) );
 
-/**
- * Searches for type of element with a certain label and performs selected
- * action on it.
- *
- * @param {NumberAndWord} cardinal provides cardinal number and word
- * @param {string} label provides required label of matching element(s)
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @returns {Promise<void>} promises step passed
- */
-export async function globalActionByLabel( cardinal, label, partially, action, input ) {
-	const api = Api.access();
-
-	if ( cardinal.cardinality !== "singular" ) {
-		await api.expect( false, `selector is not addressing a single ${cardinal.word} with ${partially ? "partial " : ""}label "${label}" to ${input == null ? action : `enter '${input}' into`}` )
-			.toEqual( true );
-	}
-
-	const matches = api.find( cardinal.word ).filterBySubsWithText( "$label", "label", label, partially );
-
-	await api.expect( matches.locator, `no single matching ${cardinal.word} with ${partially ? "partial " : ""}label "${label}" to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	await actAndTrack( cardinal, matches, action, input );
-}
 
 When( "I click (on ){cardinal-word} reading {text-or-regexp}", ( cardinal, text ) => globalActionByTextContent( cardinal, text, false, "click" ) );
 When( "I click (on ){cardinal-word} with text {text-or-regexp}", ( cardinal, text ) => globalActionByTextContent( cardinal, text, false, "click" ) );
@@ -194,29 +70,3 @@ When( "I enter {string-or-word} into {cardinal-word} with text {text-or-regexp}"
 When( "I enter {string-or-word} into {cardinal-word} partially reading {text-or-regexp}", ( input, cardinal, text ) => globalActionByTextContent( cardinal, text, true, "enter", input ) );
 When( "I enter {string-or-word} into {cardinal-word} with partial text {text-or-regexp}", ( input, cardinal, text ) => globalActionByTextContent( cardinal, text, true, "enter", input ) );
 
-/**
- * Searches for type of element with given text content and performs selected
- * action on it.
- *
- * @param {NumberAndWord} cardinal provides cardinal number and word
- * @param {string} text provides text to be found in eventually matching element(s)
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @returns {Promise<void>} promises step passed
- */
-export async function globalActionByTextContent( cardinal, text, partially, action, input ) {
-	const api = Api.access();
-
-	if ( cardinal.cardinality !== "singular" ) {
-		await api.expect( false, `selector is not addressing a single ${cardinal.word} ${partially ? "partially " : ""}reading "${text}" to ${input == null ? action : `enter '${input}' into`}` )
-			.toEqual( true );
-	}
-
-	const matches = api.find( cardinal.word ).filterBySubsWithText( "$text", false, text, partially );
-
-	await api.expect( matches.locator, `no single matching ${cardinal.word} ${partially ? "partially " : ""}reading "${text}" to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	await actAndTrack( cardinal, matches, action, input );
-}

package/steps/global-find.js

@@ -1,44 +1,21 @@
 import { Given } from "@cucumber/cucumber";
-import { Api } from "../index.js";
-import { stringMessageOperator as sOp } from "../lib/helper.js";
+import {
+	globalFind,
+	globalFindByAttribute,
+	globalFindByClass,
+	globalFindByLabel,
+	globalFindByProperty, globalFindByTextContent
+} from "../lib/step-helper.js";
 
 Given( "there is/are {cardinal-word}", globalFind );
 Given( "there is a list/set of {cardinal-word}", globalFind );
 
-/**
- * Searches for type of elements with a certain label.
- *
- * @param {NumberAndWord} cardinal provides cardinal number and word
- * @returns {Promise<void>} promises step passed
- */
-export async function globalFind( cardinal ) {
-	const api = Api.access();
-
-	await api
-		.find( cardinal.word )
-		.checkCardinalWord( cardinal );
-}
 
 Given( "there is/are {cardinal-word} with ID/id {text-or-regexp}", ( cardinal, id ) => globalFindByAttribute( cardinal, "id", id ) );
 Given( "there is/are {cardinal-word} with name {text-or-regexp}", ( cardinal, name ) => globalFindByAttribute( cardinal, "name", name ) );
 Given( "there is/are {cardinal-word} named {text-or-regexp}", ( cardinal, name ) => globalFindByAttribute( cardinal, "name", name ) );
+Given( "there is/are {cardinal-word} with icon {text-or-regexp}", ( cardinal, icon ) => globalFindByAttribute( cardinal, "icon", icon ) );
 
-/**
- * Searches for element(s) matching a named attribute by value.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string|RegExp} name name of attribute to match
- * @param {string|RegExp|boolean} value value of named attribute to match, boolean value to explicitly test for named attribute being truthy or falsy
- * @return {Promise<void>} promises step passed
- */
-export async function globalFindByAttribute( cardinal, name, value ) {
-	const api = Api.access();
-
-	await api
-		.find( cardinal.word )
-		.withAttribute( name, value )
-		.checkCardinalWord( cardinal, true, `expected %amount with ${name} ${sOp( value )} ${value}` );
-}
 
 Given( "there is/are {cardinal-word} with value {text-or-regexp}", ( cardinal, value ) => globalFindByProperty( cardinal, "value", value ) );
 Given( "there is/are {cardinal-word} which is/are enabled", cardinal => globalFindByProperty( cardinal, "disabled", false ) );
@@ -50,91 +27,18 @@ Given( "there is/are {cardinal-word} which is/are selected", cardinal => globalF
 Given( "there is/are {cardinal-word} which is/are not selected", cardinal => globalFindByProperty( cardinal, "selected", false ) );
 Given( "there is/are {cardinal-word} which is/are unselected", cardinal => globalFindByProperty( cardinal, "selected", false ) );
 
-/**
- * Searches for element(s) matching a named DOM property by value.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} name name of DOM property to match
- * @param {string|boolean} value value of named DOM property to match, or boolean value to explicitly test if property is truthy or falsy
- * @return {Promise<void>} promises step passed
- */
-export async function globalFindByProperty( cardinal, name, value ) {
-	const api = Api.access();
-
-	let text;
-
-	if ( typeof value === "boolean" ) {
-		text = `${value ? "not " : ""}${name}`;
-	} else {
-		text = `with ${name} ${sOp( value )} ${value}`;
-	}
-
-	await api
-		.find( cardinal.word )
-		.withProperty( name, value )
-		.checkCardinalWord( cardinal, true, `expected %amount ${text}` );
-}
 
 Given( "there is/are {cardinal-word} marked/tagged as {word}", ( cardinal, mark ) => globalFindByClass( cardinal, mark, false ) );
 Given( "there is/are {cardinal-word} not marked/tagged as {word}", ( cardinal, mark ) => globalFindByClass( cardinal, mark, true ) );
 
-/**
- * Searches for element(s) with a named class set.
- *
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} className name of class to test
- * @param {boolean} negated inverts the assertion by means of requiring one or all elements of context not to have selected class
- * @return {Promise<void>} promises step passed
- */
-export async function globalFindByClass( cardinal, className, negated ) {
-	const api = Api.access();
-	const matches = api
-		.find( cardinal.word )
-		.withListProperty( "classList", className, negated );
-
-	await matches.checkCardinalWord( cardinal, true, `expected %amount ${negated ? "not " : ""}marked as "${className}"` );
-}
 
 Given( "there is/are {cardinal-word} with label {text-or-regexp}", ( cardinal, label ) => globalFindByLabel( cardinal, label, false ) );
 Given( "there is/are {cardinal-word} with partial label {text-or-regexp}", ( cardinal, label ) => globalFindByLabel( cardinal, label, true ) );
 Given( "there is/are {cardinal-word} labelled with {text-or-regexp}", ( cardinal, label ) => globalFindByLabel( cardinal, label, false ) );
 Given( "there is/are {cardinal-word} partially labelled with {text-or-regexp}", ( cardinal, label ) => globalFindByLabel( cardinal, label, false ) );
 
-/**
- * Searches for type of elements with a certain label.
- *
- * @param {NumberAndWord} cardinal provides cardinal number and word
- * @param {string} label provides required label of matching element(s)
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @returns {Promise<void>} promises step passed
- */
-export async function globalFindByLabel( cardinal, label, partially ) {
-	const api = Api.access();
-
-	await api
-		.find( cardinal.word )
-		.filterBySubsWithText( "$label", "label", label, partially )
-		.checkCardinalWord( cardinal, true, `expected %amount ${partially ? "partially " : ""}labelled with "${label}"` );
-}
 
 Given( "there is/are {cardinal-word} reading {text-or-regexp}", ( cardinal, text ) => globalFindByTextContent( cardinal, text, false ) );
 Given( "there is/are {cardinal-word} with text {text-or-regexp}", ( cardinal, text ) => globalFindByTextContent( cardinal, text, false ) );
 Given( "there is/are {cardinal-word} partially reading {text-or-regexp}", ( cardinal, text ) => globalFindByTextContent( cardinal, text, true ) );
 Given( "there is/are {cardinal-word} with partial text {text-or-regexp}", ( cardinal, text ) => globalFindByTextContent( cardinal, text, true ) );
-
-/**
- * Searches for type of elements with a certain label.
- *
- * @param {NumberAndWord} cardinal provides cardinal number and word
- * @param {string} text provides text to be found in eventually matching element(s)
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @returns {Promise<void>} promises step passed
- */
-export async function globalFindByTextContent( cardinal, text, partially ) {
-	const api = Api.access();
-
-	await api
-		.find( cardinal.word )
-		.filterBySubsWithText( "$text", false, text, partially )
-		.checkCardinalWord( cardinal, true, `expected %amount ${partially ? "partially " : ""}reading "${text}"` );
-}

package/steps/local-action.js

@@ -1,5 +1,5 @@
 import { When } from "@cucumber/cucumber";
-import { Api } from "../index.js";
+import { localAction } from "../lib/step-helper.js";
 
 When( "I click (on ){contextual-word}", context => localAction( context, "click" ) );
 
@@ -7,44 +7,3 @@ When( "I hover (over ){contextual-word}", context => localAction( context, "hove
 
 When( "I enter {string-or-word} into {contextual-word}", ( input, context ) => localAction( context, "enter", input ) );
 
-/**
- * Searches for type of element in current context and performs selected action
- * on it.
- *
- * @param {ContextualWord} phrase description of element to be clicked.
- * @param {'click'|'hover'|'enter'} action action to perform on found element
- * @param {string} [input] text to enter into selected field (instead of clicking or hovering)
- * @returns {Promise<void>} promises element clicked
- */
-export async function localAction( phrase, action, input ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-
-	await api.expect( context.locator, `no single matching ${phrase.word} to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	const target = context.find( "$" + action, false );
-
-	await api.expect( target.locator, `no single matching $${action} target for selected ${phrase.word} to ${input == null ? action : `enter '${input}' into`}` )
-		.toHaveCount( 1 );
-
-	// detach matches first as interacting with them might change them in a way
-	// so that the original query isn't finding them anymore (e.g. changing
-	// label of a button on click)
-	const detached = await context.detach( phrase.targetCardinality );
-
-	if ( input == null ) {
-		await target.actions[action]();
-	} else {
-		await target.actions.fill( input );
-	}
-
-	if ( phrase.isRefining ) {
-		await detached.track( phrase.word, phrase.targetCardinality );
-	}
-
-	const wait = Number( process.env.ACTION_WAIT ) || 100;
-	if ( wait > 0 ) {
-		await api.wait( wait );
-	}
-}

package/steps/local-find.js

@@ -1,49 +1,21 @@
 import { Given } from "@cucumber/cucumber";
-import { Api } from "../index.js";
-import { stringMessageOperator as sOp } from "../lib/helper.js";
+import {
+	localFind,
+	localFindByAttribute,
+	localFindByClass,
+	localFindByLabel,
+	localFindByProperty, localFindByTextContent
+} from "../lib/step-helper.js";
 
 Given( "{contextual-word} has/have {cardinal-word}", ( context, cardinal ) => localFind( context, cardinal ) );
 Given( "{contextual-word} has/have a list/set of {cardinal-word}", ( context, cardinal ) => localFind( context, cardinal ) );
 
-/**
- * Finds elements in context of containing elements.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @return {Promise<void>} promises step passed
- */
-export async function localFind( phrase, cardinal ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-
-	await context
-		.find( cardinal.word )
-		.checkCardinalWord( cardinal );
-}
 
 Given( "{contextual-word} has/have {cardinal-word} with ID/id {text-or-regexp}", ( context, cardinal, id ) => localFindByAttribute( context, cardinal, "id", id ) );
 Given( "{contextual-word} has/have {cardinal-word} with name {text-or-regexp}", ( context, cardinal, name ) => localFindByAttribute( context, cardinal, "name", name ) );
 Given( "{contextual-word} has/have {cardinal-word} named {text-or-regexp}", ( context, cardinal, name ) => localFindByAttribute( context, cardinal, "name", name ) );
+Given( "{contextual-word} has/have {cardinal-word} with icon {text-or-regexp}", ( context, cardinal, icon ) => localFindByAttribute( context, cardinal, "icon", icon ) );
 
-/**
- * Finds elements in context of containing elements matching a named attribute
- * by value.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string|RegExp} name name of attribute to match
- * @param {string|RegExp} value value of named attribute to match
- * @return {Promise<void>} promises step passed
- */
-export async function localFindByAttribute( phrase, cardinal, name, value ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-
-	await context
-		.find( cardinal.word )
-		.withAttribute( name, value )
-		.checkCardinalWord( cardinal, true, `expected %amount with ${name} ${sOp( value )} ${value}` );
-}
 
 Given( "{contextual-word} has/have {cardinal-word} with value {text-or-regexp}", ( context, cardinal, value ) => localFindByProperty( context, cardinal, "value", value ) );
 Given( "{contextual-word} has/have {cardinal-word} which is/are enabled", ( context, cardinal ) => localFindByProperty( context, cardinal, "disabled", false ) );
@@ -52,99 +24,18 @@ Given( "{contextual-word} has/have {cardinal-word} which is/are checked", ( cont
 Given( "{contextual-word} has/have {cardinal-word} which is/are not checked", ( context, cardinal ) => localFindByProperty( context, cardinal, "checked", false ) );
 Given( "{contextual-word} has/have {cardinal-word} which is/are unchecked", ( context, cardinal ) => localFindByProperty( context, cardinal, "checked", false ) );
 
-/**
- * Finds elements in context of containing elements matching a named DOM
- * property by value.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} name name of DOM property to match
- * @param {string|boolean} value value of named DOM property to match, or boolean to explicitly test named property for being truthy or falsy
- * @return {Promise<void>} promises step passed
- */
-export async function localFindByProperty( phrase, cardinal, name, value ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-	let text;
-
-	if ( typeof value === "boolean" ) {
-		text = `${value ? "" : "not "}${name}`;
-	} else {
-		text = `with ${name} ${value instanceof RegExp ? "matching" : "equals"} ${value}`;
-	}
-
-	await context
-		.find( cardinal.word )
-		.withProperty( name, value )
-		.checkCardinalWord( cardinal, true, `expected %amount ${text}` );
-}
 
 Given( "{contextual-word} has/have {cardinal-word} marked/tagged as {word}", ( context, cardinal, className ) => localFindByClass( context, cardinal, className, false ) );
 Given( "{contextual-word} has/have {cardinal-word} not marked/tagged as {word}", ( context, cardinal, className ) => localFindByClass( context, cardinal, className, true ) );
 
-/**
- * Finds elements in context of containing elements with named class.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} className name of class to check
- * @param {boolean} negated inverts the assertion by means of requiring one or all elements of context not to have selected class
- * @return {Promise<void>} promises step passed
- */
-export async function localFindByClass( phrase, cardinal, className, negated ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-	const matches = context.find( cardinal.word );
-
-	await matches
-		.withListProperty( "classList", className, negated )
-		.checkCardinalWord( cardinal, true, `expected %amount ${negated ? "not " : ""}marked as "${className}"` );
-}
 
 Given( "{contextual-word} has/have {cardinal-word} with label {text-or-regexp}", ( context, cardinal, label ) => localFindByLabel( context, cardinal, label, false ) );
 Given( "{contextual-word} has/have {cardinal-word} with partial label {text-or-regexp}", ( context, cardinal, label ) => localFindByLabel( context, cardinal, label, true ) );
 Given( "{contextual-word} has/have {cardinal-word} labelled with {text-or-regexp}", ( context, cardinal, label ) => localFindByLabel( context, cardinal, label, false ) );
 Given( "{contextual-word} has/have {cardinal-word} partially labelled with {text-or-regexp}", ( context, cardinal, label ) => localFindByLabel( context, cardinal, label, true ) );
 
-/**
- * Finds elements in context of containing elements with a given label.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} label expected label of item(s) to find
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @return {Promise<void>} promises step passed
- */
-export async function localFindByLabel( phrase, cardinal, label, partially ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-
-	await context
-		.find( cardinal.word )
-		.filterBySubsWithText( "$label", "label", label, partially )
-		.checkCardinalWord( cardinal, true, `expected %amount ${partially ? "partially " : ""}labelled with "${label}"` );
-}
 
 Given( "{contextual-word} has/have {cardinal-word} reading {text-or-regexp}", ( context, cardinal, text ) => localFindByTextContent( context, cardinal, text, false ) );
 Given( "{contextual-word} has/have {cardinal-word} with text {text-or-regexp}", ( context, cardinal, text ) => localFindByTextContent( context, cardinal, text, false ) );
 Given( "{contextual-word} has/have {cardinal-word} partially reading {text-or-regexp}", ( context, cardinal, text ) => localFindByTextContent( context, cardinal, text, true ) );
 Given( "{contextual-word} has/have {cardinal-word} with partial text {text-or-regexp}", ( context, cardinal, text ) => localFindByTextContent( context, cardinal, text, true ) );
-
-/**
- * Finds elements in context of containing elements containing given text.
- *
- * @param {ContextualWord} phrase describes context of search
- * @param {NumberAndWord} cardinal describes what to search
- * @param {string} text provides expected text content of item(s) to find
- * @param {boolean} partially if true, provided text does not have to match whole content of matching subs
- * @return {Promise<void>} promises step passed
- */
-export async function localFindByTextContent( phrase, cardinal, text, partially ) {
-	const api = Api.access();
-	const context = api.getContextFor( phrase );
-
-	await context
-		.find( cardinal.word )
-		.filterBySubsWithText( "$text", false, text, partially )
-		.checkCardinalWord( cardinal, true, `expected %amount ${partially ? "partially " : ""}reading "${text}"` );
-}