Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore(locators): rewrite locator parser with per-language parsers (#42895)

Yury Semikhatskyd6a10f6eb367
diff --git a/packages/isomorphic/locatorGenerators.ts b/packages/isomorphic/locatorGenerators.ts
index 4aec1339aa..7522baf51e 100644
--- a/packages/isomorphic/locatorGenerators.ts
+++ b/packages/isomorphic/locatorGenerators.ts
@@ -493,7 +493,7 @@ export class PythonLocatorFactory implements LocatorFactory {
}
private regexToString(body: RegExp) {
- const suffix = body.flags.includes('i') ? ', re.IGNORECASE' : '';
+ const suffix = regexFlagsSuffix(body, 're', regexFlagNames.python);
return `re.compile(r"${normalizeEscapedRegexQuotes(body.source).replace(/\\\//, '/').replace(/"/g, '\\"')}"${suffix})`;
}
@@ -605,7 +605,7 @@ export class JavaLocatorFactory implements LocatorFactory {
}
private regexToString(body: RegExp) {
- const suffix = body.flags.includes('i') ? ', Pattern.CASE_INSENSITIVE' : '';
+ const suffix = regexFlagsSuffix(body, 'Pattern', regexFlagNames.java);
return `Pattern.compile(${this.quote(normalizeEscapedRegexQuotes(body.source))}${suffix})`;
}
@@ -711,7 +711,7 @@ export class CSharpLocatorFactory implements LocatorFactory {
}
private regexToString(body: RegExp): string {
- const suffix = body.flags.includes('i') ? ', RegexOptions.IgnoreCase' : '';
+ const suffix = regexFlagsSuffix(body, 'RegexOptions', regexFlagNames.csharp);
return `new Regex(${this.quote(normalizeEscapedRegexQuotes(body.source))}${suffix})`;
}
@@ -776,6 +776,19 @@ const generators: Record<Language, new (preferredQuote?: Quote) => LocatorFactor
jsonl: JsonlLocatorFactory,
};
+// Regular expression flags supported by the Python, Java and C# locators.
+export const regexFlagNames = {
+ python: { i: 'IGNORECASE', m: 'MULTILINE', s: 'DOTALL' },
+ java: { i: 'CASE_INSENSITIVE', m: 'MULTILINE', s: 'DOTALL' },
+ csharp: { i: 'IgnoreCase', m: 'Multiline', s: 'Singleline' },
+};
+
+// E.g. `, re.IGNORECASE | re.MULTILINE`.
+function regexFlagsSuffix(body: RegExp, flagsEnum: string, names: Record<string, string>): string {
+ const flags = [...body.flags].filter(flag => flag in names).map(flag => `${flagsEnum}.${names[flag]}`);
+ return flags.length ? `, ${flags.join(' | ')}` : '';
+}
+
function isRegExp(obj: any): obj is RegExp {
return obj instanceof RegExp;
}
diff --git a/packages/isomorphic/locatorParser.ts b/packages/isomorphic/locatorParser.ts
index 6f5c8ac31e..52672077e7 100644
--- a/packages/isomorphic/locatorParser.ts
+++ b/packages/isomorphic/locatorParser.ts
@@ -14,212 +14,625 @@
* limitations under the License.
*/
-import { asLocators } from './locatorGenerators';
-import { encodeTestIdAttributeName } from './locatorUtils';
-import { parseSelector } from './selectorParser';
+import { regexFlagNames } from './locatorGenerators';
+import { getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector } from './locatorUtils';
+import { parseSelector, stringifySelector } from './selectorParser';
import { escapeForAttributeSelector, escapeForTextSelector } from './stringUtils';
-import type { Language, Quote } from './locatorGenerators';
-
-type TemplateParams = { quote: string, text: string }[];
-function parseLocator(locator: string, testIdAttributeName: string): { selector: string, preferredQuote: Quote | undefined } {
- locator = locator
- .replace(/AriaRole\s*\.\s*([\w]+)/g, (_, group) => group.toLowerCase())
- .replace(/(get_by_role|getByRole)\s*\(\s*(?:["'`])([^'"`]+)['"`]/g, (_, group1, group2) => `${group1}(${group2.toLowerCase()}`);
- const params: TemplateParams = [];
- let template = '';
- for (let i = 0; i < locator.length; ++i) {
- const quote = locator[i];
- if (quote !== '"' && quote !== '\'' && quote !== '`' && quote !== '/') {
- template += quote;
- continue;
- }
- const isRegexEscaping = locator[i - 1] === 'r' || locator[i] === '/';
- ++i;
+import type { Language } from './locatorGenerators';
+import type { ParsedSelector, ParsedSelectorPart } from './selectorParser';
+
+type Value = string | number | boolean | RegExp | ParsedSelector;
+
+// Arguments of a single call, collected until the call is converted into selector parts.
+type CallArguments = {
+ method: string;
+ args: Value[];
+ options: Map<string, Value>;
+};
+
+type CallHandler = (call: CallArguments, testIdAttributeName: string) => ParsedSelectorPart[];
+
+type Token =
+ | { kind: 'identifier', value: string }
+ | { kind: 'string', value: string }
+ | { kind: 'regex', value: RegExp }
+ | { kind: 'number', value: number }
+ | { kind: 'punctuation', value: string }
+ | { kind: 'end' };
+
+type ParserOptions = {
+ methods: Map<string, CallHandler>;
+ quotes: string;
+ rawStrings?: boolean;
+ regexLiterals?: boolean;
+ booleans?: [string, string];
+};
+
+const kEscapes = new Map([['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f']]);
+const kIdentifierRegex = /[A-Za-z_$][\w$]*/y;
+const kNumberRegex = /-?\d+(\.\d+)?/y;
+const kRegexFlagsRegex = /[a-z]*/y;
+
+function tokenize(source: string, options: ParserOptions): Token[] {
+ const tokens: Token[] = [];
+ let pos = 0;
+
+ const match = (re: RegExp) => {
+ re.lastIndex = pos;
+ const result = re.exec(source)?.[0];
+ if (result)
+ pos += result.length;
+ return result;
+ };
+
+ // In raw strings, backslash only escapes the closing quote and is preserved otherwise.
+ const readString = (quote: string, raw: boolean) => {
let text = '';
- while (i < locator.length) {
- if (locator[i] === '\\') {
- if (isRegexEscaping) {
- if (locator[i + 1] !== quote)
- text += locator[i];
- ++i;
- text += locator[i];
- } else {
- ++i;
- if (locator[i] === 'n')
- text += '\n';
- else if (locator[i] === 'r')
- text += '\r';
- else if (locator[i] === 't')
- text += '\t';
- else
- text += locator[i];
- }
- ++i;
+ ++pos;
+ while (pos < source.length && source[pos] !== quote) {
+ if (source[pos] !== '\\') {
+ text += source[pos++];
continue;
}
- if (locator[i] !== quote) {
- text += locator[i++];
- continue;
+ const next = source[pos + 1] ?? '';
+ pos += 2;
+ if (raw) {
+ text += next === quote ? next : '\\' + next;
+ } else if (next === 'u') {
+ text += String.fromCharCode(parseInt(source.substring(pos, pos + 4), 16));
+ pos += 4;
+ } else {
+ text += kEscapes.get(next) ?? next;
+ }
+ }
+ if (pos >= source.length)
+ throw new Error(`Unterminated string in ${source}`);
+ ++pos;
+ return text;
+ };
+
+ while (pos < source.length) {
+ const char = source[pos];
+ let text: string | undefined;
+ if (/\s/.test(char)) {
+ ++pos;
+ } else if (options.quotes.includes(char)) {
+ tokens.push({ kind: 'string', value: readString(char, false) });
+ } else if (options.rawStrings && char === 'r' && options.quotes.includes(source[pos + 1])) {
+ tokens.push({ kind: 'string', value: readString(source[++pos], true) });
+ } else if (options.regexLiterals && char === '/') {
+ const regexSource = readString('/', true);
+ tokens.push({ kind: 'regex', value: new RegExp(regexSource, match(kRegexFlagsRegex)) });
+ } else if ('(){}.,:=|'.includes(char)) {
+ tokens.push({ kind: 'punctuation', value: char });
+ ++pos;
+ } else if ((text = match(kIdentifierRegex))) {
+ tokens.push({ kind: 'identifier', value: text });
+ } else if ((text = match(kNumberRegex))) {
+ tokens.push({ kind: 'number', value: +text });
+ } else {
+ throw new Error(`Unexpected character "${char}" in ${source}`);
+ }
+ }
+ tokens.push({ kind: 'end' });
+ return tokens;
+}
+
+function isToken(token: Token, kind: 'identifier' | 'punctuation', value: string): boolean {
+ return token.kind === kind && token.value === value;
+}
+
+abstract class LocatorParser {
+ private _tokens: Token[];
+ private _pos = 0;
+ private _methods: Map<string, CallHandler>;
+ private _booleans: [string, string];
+ private _testIdAttributeName: string;
+
+ constructor(source: string, options: ParserOptions, testIdAttributeName: string) {
+ this._tokens = tokenize(source, options);
+ this._methods = options.methods;
+ this._booleans = options.booleans ?? ['true', 'false'];
+ this._testIdAttributeName = testIdAttributeName;
+ }
+
+ parse(): ParsedSelector {
+ const selector = this.parseLocator();
+ if (this.peek().kind !== 'end')
+ this.unexpected();
+ // Same as in parseSelector(), nested selectors like internal:chain cannot be first.
+ if (selector.parts.length && isNestedSelectorPart(selector.parts[0]))
+ throw new Error(`"${selector.parts[0].name}" selector cannot be first`);
+ return selector;
+ }
+
+ // Parses a single argument that is either a positional value or an options bag.
+ protected abstract parseArgument(call: CallArguments): void;
+
+ // Parses a language-specific regular expression, e.g. `re.compile(...)`.
+ protected abstract parseRegex(): RegExp | undefined;
+
+ protected parseLocator(): ParsedSelector {
+ const parts: ParsedSelectorPart[] = [];
+ // FrameLocator enters the frame lazily, so that first(), last() and nth() apply to the frame element.
+ let inFrameLocator = false;
+ do {
+ const { handler, call } = this.parseCall();
+ if (inFrameLocator && !kFrameElementHandlers.has(handler)) {
+ parts.push(selectorPart('internal:control', 'enter-frame'));
+ inFrameLocator = false;
}
- break;
+ parts.push(...handler(call, this._testIdAttributeName));
+ if (handler === contentFrameParts || (handler === frameLocatorParts && call.args.length))
+ inFrameLocator = true;
+ } while (this.eat('.'));
+ if (inFrameLocator)
+ parts.push(selectorPart('internal:control', 'enter-frame'));
+ return { parts };
+ }
+
+ private parseCall(): { handler: CallHandler, call: CallArguments } {
+ const method = this.expectIdentifier();
+ const handler = this._methods.get(method);
+ if (!handler)
+ throw new Error(`Unsupported locator method ${method}`);
+ const call: CallArguments = { method, args: [], options: new Map() };
+ if (this.eat('(') && !this.eat(')')) {
+ do
+ this.parseArgument(call);
+ while (this.eat(','));
+ this.expect(')');
}
- params.push({ quote, text });
- template += (quote === '/' ? 'r' : '') + '$' + params.length;
- }
-
- // Equalize languages.
- template = template.toLowerCase()
- .replace(/get_by_alt_text/g, 'getbyalttext')
- .replace(/get_by_test_id/g, 'getbytestid')
- .replace(/get_by_([\w]+)/g, 'getby$1')
- .replace(/has_not_text/g, 'hasnottext')
- .replace(/has_text/g, 'hastext')
- .replace(/has_not/g, 'hasnot')
- .replace(/frame_locator/g, 'framelocator')
- .replace(/content_frame/g, 'contentframe')
- .replace(/[{}\s]/g, '')
- .replace(/new\(\)/g, '')
- .replace(/new[\w]+\.[\w]+options\(\)/g, '')
- .replace(/\.set/g, ',set')
- .replace(/\.or_\(/g, 'or(') // Python has "or_" instead of "or".
- .replace(/\.and_\(/g, 'and(') // Python has "and_" instead of "and".
- .replace(/:/g, '=')
- .replace(/,re\.ignorecase/g, 'i')
- .replace(/,pattern.case_insensitive/g, 'i')
- .replace(/,regexoptions.ignorecase/g, 'i')
- .replace(/re.compile\(([^)]+)\)/g, '$1') // Python has regex strings as r"foo"
- .replace(/pattern.compile\(([^)]+)\)/g, 'r$1')
- .replace(/newregex\(([^)]+)\)/g, 'r$1')
- .replace(/string=/g, '=')
- .replace(/regex=/g, '=')
- .replace(/,,/g, ',')
- .replace(/,\)/g, ')');
-
- const preferredQuote = params.map(p => p.quote).filter(quote => '\'"`'.includes(quote))[0] as Quote | undefined;
- return { selector: transform(template, params, testIdAttributeName), preferredQuote };
-}
-
-function countParams(template: string) {
- return [...template.matchAll(/\$\d+/g)].length;
-}
-
-function shiftParams(template: string, sub: number) {
- return template.replace(/\$(\d+)/g, (_, ordinal) => `$${ordinal - sub}`);
-}
-
-function transform(template: string, params: TemplateParams, testIdAttributeName: string): string {
- // Recursively handle filter(has=, hasnot=, sethas(), sethasnot()).
- // TODO: handle and(locator), or(locator), locator(locator), locator(has=, hasnot=, sethas(), sethasnot()).
- while (true) {
- const hasMatch = template.match(/filter\(,?(has=|hasnot=|sethas\(|sethasnot\()/);
- if (!hasMatch)
- break;
-
- // Extract inner locator based on balanced parens.
- const start = hasMatch.index! + hasMatch[0].length;
- let balance = 0;
- let end = start;
- for (; end < template.length; end++) {
- if (template[end] === '(')
- balance++;
- else if (template[end] === ')')
- balance--;
- if (balance < 0)
+ return { handler, call };
+ }
+
+ protected parseValue(): Value {
+ const token = this.peek();
+ if (token.kind === 'string' || token.kind === 'number' || token.kind === 'regex') {
+ this.next();
+ return token.value;
+ }
+ if (token.kind !== 'identifier')
+ this.unexpected();
+ const [trueLiteral, falseLiteral] = this._booleans;
+ if (this.eatIdentifier(trueLiteral))
+ return true;
+ if (this.eatIdentifier(falseLiteral))
+ return false;
+ // Java and C# roles, e.g. `AriaRole.BUTTON`.
+ if (this.eatIdentifier('AriaRole')) {
+ this.expect('.');
+ return this.expectIdentifier().toLowerCase();
+ }
+ return this.parseRegex() ?? this.parseLocator();
+ }
+
+ // Parses `{ name <separator> value, ... }` after the opening brace.
+ protected parseOptionsBag(call: CallArguments, separator: string, optionName: (identifier: string) => string) {
+ while (!this.eat('}')) {
+ const name = optionName(this.expectIdentifier());
+ this.expect(separator);
+ call.options.set(name, this.parseValue());
+ if (!this.eat(',')) {
+ this.expect('}');
break;
+ }
+ }
+ }
+
+ // Parses `(source[, <flagsEnum>.<flag> ( "|" <flagsEnum>.<flag> )*])`.
+ protected parseRegexArguments(flagsEnum: string, flagNames: Record<string, string>): RegExp {
+ this.expect('(');
+ const source = this.expectString();
+ let flags = '';
+ if (this.eat(',')) {
+ do {
+ this.expectIdentifier(flagsEnum);
+ this.expect('.');
+ const name = this.expectIdentifier();
+ const flag = Object.keys(flagNames).find(flag => flagNames[flag] === name);
+ if (!flag)
+ throw new Error(`Unsupported regular expression flag ${flagsEnum}.${name}`);
+ flags += flag;
+ } while (this.eat('|'));
+ }
+ this.expect(')');
+ return new RegExp(source, flags);
+ }
+
+ protected peek(offset = 0): Token {
+ return this._tokens[Math.min(this._pos + offset, this._tokens.length - 1)];
+ }
+
+ protected next(): Token {
+ const token = this.peek();
+ if (token.kind !== 'end')
+ ++this._pos;
+ return token;
+ }
+
+ protected eat(punctuation: string): boolean {
+ if (!isToken(this.peek(), 'punctuation', punctuation))
+ return false;
+ this.next();
+ return true;
+ }
+
+ protected eatIdentifier(identifier: string): boolean {
+ if (!isToken(this.peek(), 'identifier', identifier))
+ return false;
+ this.next();
+ return true;
+ }
+
+ protected expect(punctuation: string) {
+ if (!this.eat(punctuation))
+ this.unexpected();
+ }
+
+ protected expectIdentifier(identifier?: string): string {
+ const token = this.peek();
+ if (token.kind !== 'identifier' || (identifier !== undefined && token.value !== identifier))
+ this.unexpected();
+ this.next();
+ return token.value;
+ }
+
+ protected expectString(): string {
+ const token = this.next();
+ if (token.kind !== 'string')
+ this.unexpected();
+ return token.value;
+ }
+
+ protected unexpected(): never {
+ const token = this.peek();
+ throw new Error(`Unexpected ${token.kind === 'end' ? 'end of input' : `token "${token.value}"`}`);
+ }
+}
+
+// getByRole('button', { name: /submit/i, exact: true })
+class JavaScriptLocatorParser extends LocatorParser {
+ constructor(source: string, testIdAttributeName: string) {
+ super(source, { methods: kJavaScriptMethods, quotes: '\'"`', regexLiterals: true }, testIdAttributeName);
+ }
+
+ protected parseArgument(call: CallArguments) {
+ if (this.eat('{'))
+ this.parseOptionsBag(call, ':', name => name);
+ else
+ call.args.push(this.parseValue());
+ }
+
+ // Regular expression literals are tokens.
+ protected parseRegex(): RegExp | undefined {
+ return undefined;
+ }
+}
+
+// get_by_role("button", name=re.compile(r"submit", re.IGNORECASE), exact=True)
+class PythonLocatorParser extends LocatorParser {
+ constructor(source: string, testIdAttributeName: string) {
+ super(source, { methods: kPythonMethods, quotes: '\'"', rawStrings: true, booleans: ['True', 'False'] }, testIdAttributeName);
+ }
+
+ protected parseArgument(call: CallArguments) {
+ if (!isToken(this.peek(1), 'punctuation', '=')) {
+ call.args.push(this.parseValue());
+ return;
}
+ const name = this.expectIdentifier();
+ this.expect('=');
+ call.options.set(name.replace(/_([a-z])/g, (_, char) => char.toUpperCase()), this.parseValue());
+ }
+
+ protected parseRegex(): RegExp | undefined {
+ if (!this.eatIdentifier('re'))
+ return;
+ this.expect('.');
+ this.expectIdentifier('compile');
+ return this.parseRegexArguments('re', regexFlagNames.python);
+ }
+}
+
+// getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName(Pattern.compile("submit", Pattern.CASE_INSENSITIVE)).setExact(true))
+class JavaLocatorParser extends LocatorParser {
+ constructor(source: string, testIdAttributeName: string) {
+ super(source, { methods: kJavaScriptMethods, quotes: '"' }, testIdAttributeName);
+ }
- // Replace Java sethas(...) and sethasnot(...) with has=... and hasnot=...
- let prefix = template.substring(0, start);
- let extraSymbol = 0;
- if (['sethas(', 'sethasnot('].includes(hasMatch[1])) {
- // Eat extra ) symbol at the end of sethas(...)
- extraSymbol = 1;
- prefix = prefix.replace(/sethas\($/, 'has=').replace(/sethasnot\($/, 'hasnot=');
+ protected parseArgument(call: CallArguments) {
+ if (!this.eatIdentifier('new')) {
+ call.args.push(this.parseValue());
+ return;
}
+ // Options class, e.g. `Locator.FilterOptions`.
+ this.expectIdentifier();
+ this.expect('.');
+ this.expectIdentifier();
+ this.expect('(');
+ this.expect(')');
+ while (this.eat('.')) {
+ const setter = this.expectIdentifier();
+ if (!setter.startsWith('set'))
+ throw new Error(`Unexpected options method ${setter}`);
+ this.expect('(');
+ call.options.set(lowerFirst(setter.substring('set'.length)), this.parseValue());
+ this.expect(')');
+ }
+ }
+
+ protected parseRegex(): RegExp | undefined {
+ if (!this.eatIdentifier('Pattern'))
+ return;
+ this.expect('.');
+ this.expectIdentifier('compile');
+ return this.parseRegexArguments('Pattern', regexFlagNames.java);
+ }
+}
+
+// GetByRole(AriaRole.Button, new() { NameRegex = new Regex("submit", RegexOptions.IgnoreCase), Exact = true })
+class CSharpLocatorParser extends LocatorParser {
+ constructor(source: string, testIdAttributeName: string) {
+ super(source, { methods: kCSharpMethods, quotes: '"' }, testIdAttributeName);
+ }
- const paramsCountBeforeHas = countParams(template.substring(0, start));
- const hasTemplate = shiftParams(template.substring(start, end), paramsCountBeforeHas);
- const paramsCountInHas = countParams(hasTemplate);
- const hasParams = params.slice(paramsCountBeforeHas, paramsCountBeforeHas + paramsCountInHas);
- const hasSelector = JSON.stringify(transform(hasTemplate, hasParams, testIdAttributeName));
-
- // Replace filter(has=...) with filter(has2=$5). Use has2 to avoid matching the same filter again.
- // Replace filter(hasnot=...) with filter(hasnot2=$5). Use hasnot2 to avoid matching the same filter again.
- template = prefix.replace(/=$/, '2=') + `$${paramsCountBeforeHas + 1}` + shiftParams(template.substring(end + extraSymbol), paramsCountInHas - 1);
-
- // Replace inner params with $5 value.
- const paramsBeforeHas = params.slice(0, paramsCountBeforeHas);
- const paramsAfterHas = params.slice(paramsCountBeforeHas + paramsCountInHas);
- params = paramsBeforeHas.concat([{ quote: '"', text: hasSelector }]).concat(paramsAfterHas);
- }
-
- // Transform to selector engines.
- template = template
- .replace(/\,set([\w]+)\(([^)]+)\)/g, (_, group1, group2) => ',' + group1.toLowerCase() + '=' + group2.toLowerCase())
- .replace(/framelocator\(\)/g, 'internal:control=any-frame')
- .replace(/framelocator\(([^)]+)\)/g, '$1.internal:control=enter-frame')
- .replace(/contentframe(\(\))?/g, 'internal:control=enter-frame')
- .replace(/locator\(([^)]+),hastext=([^),]+)\)/g, 'locator($1).internal:has-text=$2')
- .replace(/locator\(([^)]+),hasnottext=([^),]+)\)/g, 'locator($1).internal:has-not-text=$2')
- .replace(/locator\(([^)]+),hastext=([^),]+)\)/g, 'locator($1).internal:has-text=$2')
- .replace(/locator\(([^)]+)\)/g, '$1')
- .replace(/getbyrole\(([^)]+)\)/g, 'internal:role=$1')
- .replace(/getbytext\(([^)]+)\)/g, 'internal:text=$1')
- .replace(/getbylabel\(([^)]+)\)/g, 'internal:label=$1')
- .replace(/getbytestid\(([^)]+)\)/g, `internal:testid=[${encodeTestIdAttributeName(testIdAttributeName)}=$1]`)
- .replace(/getby(placeholder|alt|title)(?:text)?\(([^)]+)\)/g, 'internal:attr=[$1=$2]')
- .replace(/first(\(\))?/g, 'nth=0')
- .replace(/last(\(\))?/g, 'nth=-1')
- .replace(/nth\(([^)]+)\)/g, 'nth=$1')
- .replace(/filter\(,?visible=true\)/g, 'visible=true')
- .replace(/filter\(,?visible=false\)/g, 'visible=false')
- .replace(/\.visible(\(\))?(?!=)/g, '.visible=true')
- .replace(/filter\(,?hastext=([^)]+)\)/g, 'internal:has-text=$1')
- .replace(/filter\(,?hasnottext=([^)]+)\)/g, 'internal:has-not-text=$1')
- .replace(/filter\(,?has2=([^)]+)\)/g, 'internal:has=$1')
- .replace(/filter\(,?hasnot2=([^)]+)\)/g, 'internal:has-not=$1')
- .replace(/,exact=false/g, '')
- .replace(/(,name=\$\d+)(,description=\$\d+),exact=true/g, '$1s$2s') // exact=true is shared between name and description, so we need a special case for applying it to both.
- .replace(/,exact=true/g, 's')
- .replace(/,includehidden=/g, ',include-hidden=')
- .replace(/\,/g, '][');
-
- const parts = template.split('.');
- // Turn "internal:control=enter-frame >> nth=0" into "nth=0 >> internal:control=enter-frame"
- // because these are swapped in locators vs selectors.
- for (let index = 0; index < parts.length - 1; index++) {
- if (parts[index] === 'internal:control=enter-frame' && parts[index + 1].startsWith('nth=')) {
- // Swap nth and enter-frame.
- const [nth] = parts.splice(index, 1);
- parts.splice(index + 1, 0, nth);
+ protected parseArgument(call: CallArguments) {
+ // `new() { ... }` is an options bag, while `new Regex(...)` is a value.
+ if (!isToken(this.peek(), 'identifier', 'new') || !isToken(this.peek(1), 'punctuation', '(')) {
+ call.args.push(this.parseValue());
+ return;
}
+ this.next();
+ this.expect('(');
+ this.expect(')');
+ this.expect('{');
+ // Regular expression options have a "Regex" suffix, e.g. `NameRegex`.
+ this.parseOptionsBag(call, '=', name => lowerFirst(name.replace(/Regex$/, '')));
+ }
+
+ protected parseRegex(): RegExp | undefined {
+ if (!this.eatIdentifier('new'))
+ return;
+ this.expectIdentifier('Regex');
+ return this.parseRegexArguments('RegexOptions', regexFlagNames.csharp);
+ }
+}
+
+const parsers: Partial<Record<Language, new (source: string, testIdAttributeName: string) => LocatorParser>> = {
+ javascript: JavaScriptLocatorParser,
+ python: PythonLocatorParser,
+ java: JavaLocatorParser,
+ csharp: CSharpLocatorParser,
+};
+
+const kFilterOptions = ['hasText', 'hasNotText', 'has', 'hasNot', 'visible'];
+
+function locatorParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 1, kFilterOptions);
+ const inner = arg(call, 0, (value): value is string | ParsedSelector => isString(value) || isSelector(value));
+ const parts = isString(inner) ? parseSelector(inner).parts : [nestedSelectorPart('internal:chain', inner)];
+ return [...parts, ...filterSelectorParts(call)];
+}
+
+function filterParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 0, kFilterOptions);
+ return filterSelectorParts(call);
+}
+
+function nestedParts(name: string): CallHandler {
+ return call => {
+ checkArguments(call, 1, []);
+ return [nestedSelectorPart(name, arg(call, 0, isSelector))];
+ };
+}
+
+function frameLocatorParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 1, []);
+ return call.args.length ? parseSelector(arg(call, 0, isString)).parts : [selectorPart('internal:control', 'any-frame')];
+}
+
+// Entering the frame is deferred by the parser.
+function contentFrameParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 0, []);
+ return [];
+}
+
+function fixedNthParts(index: string): CallHandler {
+ return call => {
+ checkArguments(call, 0, []);
+ return [selectorPart('nth', index)];
+ };
+}
+
+function nthParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 1, []);
+ return [selectorPart('nth', String(arg(call, 0, isNumber)))];
+}
+
+function visibleParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 0, []);
+ return [selectorPart('visible', 'true')];
+}
+
+function getByTestIdParts(call: CallArguments, testIdAttributeName: string): ParsedSelectorPart[] {
+ checkArguments(call, 1, []);
+ return parseSelector(getByTestIdSelector(testIdAttributeName, arg(call, 0, isText))).parts;
+}
+
+function textParts(toSelector: (text: string | RegExp, options: { exact?: boolean }) => string): CallHandler {
+ return call => {
+ checkArguments(call, 1, ['exact']);
+ return parseSelector(toSelector(arg(call, 0, isText), { exact: option(call, 'exact', isBoolean) })).parts;
+ };
+}
+
+const andParts = nestedParts('internal:and');
+const orParts = nestedParts('internal:or');
+const firstParts = fixedNthParts('0');
+const lastParts = fixedNthParts('-1');
+const getByTextParts = textParts(getByTextSelector);
+const getByLabelParts = textParts(getByLabelSelector);
+const getByAltTextParts = textParts(getByAltTextSelector);
+const getByPlaceholderParts = textParts(getByPlaceholderSelector);
+const getByTitleParts = textParts(getByTitleSelector);
+
+const kFrameElementHandlers = new Set<CallHandler>([firstParts, lastParts, nthParts]);
+
+// JavaScript and Java share the method names.
+const kJavaScriptMethods = new Map<string, CallHandler>([
+ ['locator', locatorParts],
+ ['filter', filterParts],
+ ['and', andParts],
+ ['or', orParts],
+ ['frameLocator', frameLocatorParts],
+ ['contentFrame', contentFrameParts],
+ ['first', firstParts],
+ ['last', lastParts],
+ ['nth', nthParts],
+ ['visible', visibleParts],
+ ['getByRole', getByRoleParts],
+ ['getByText', getByTextParts],
+ ['getByLabel', getByLabelParts],
+ ['getByTestId', getByTestIdParts],
+ ['getByAltText', getByAltTextParts],
+ ['getByPlaceholder', getByPlaceholderParts],
+ ['getByTitle', getByTitleParts],
+]);
+
+const kPythonMethods = new Map<string, CallHandler>([
+ ['locator', locatorParts],
+ ['filter', filterParts],
+ ['and_', andParts],
+ ['or_', orParts],
+ ['frame_locator', frameLocatorParts],
+ ['content_frame', contentFrameParts],
+ ['first', firstParts],
+ ['last', lastParts],
+ ['nth', nthParts],
+ ['visible', visibleParts],
+ ['get_by_role', getByRoleParts],
+ ['get_by_text', getByTextParts],
+ ['get_by_label', getByLabelParts],
+ ['get_by_test_id', getByTestIdParts],
+ ['get_by_alt_text', getByAltTextParts],
+ ['get_by_placeholder', getByPlaceholderParts],
+ ['get_by_title', getByTitleParts],
+]);
+
+const kCSharpMethods = new Map<string, CallHandler>([
+ ['Locator', locatorParts],
+ ['Filter', filterParts],
+ ['And', andParts],
+ ['Or', orParts],
+ ['FrameLocator', frameLocatorParts],
+ ['ContentFrame', contentFrameParts],
+ ['First', firstParts],
+ ['Last', lastParts],
+ ['Nth', nthParts],
+ ['Visible', visibleParts],
+ ['GetByRole', getByRoleParts],
+ ['GetByText', getByTextParts],
+ ['GetByLabel', getByLabelParts],
+ ['GetByTestId', getByTestIdParts],
+ ['GetByAltText', getByAltTextParts],
+ ['GetByPlaceholder', getByPlaceholderParts],
+ ['GetByTitle', getByTitleParts],
+]);
+
+function filterSelectorParts(call: CallArguments): ParsedSelectorPart[] {
+ const parts: ParsedSelectorPart[] = [];
+ const hasText = option(call, 'hasText', isText);
+ if (hasText !== undefined)
+ parts.push(selectorPart('internal:has-text', escapeForTextSelector(hasText, false)));
+ const hasNotText = option(call, 'hasNotText', isText);
+ if (hasNotText !== undefined)
+ parts.push(selectorPart('internal:has-not-text', escapeForTextSelector(hasNotText, false)));
+ const has = option(call, 'has', isSelector);
+ if (has)
+ parts.push(nestedSelectorPart('internal:has', has));
+ const hasNot = option(call, 'hasNot', isSelector);
+ if (hasNot)
+ parts.push(nestedSelectorPart('internal:has-not', hasNot));
+ const visible = option(call, 'visible', isBoolean);
+ if (visible !== undefined)
+ parts.push(selectorPart('visible', String(visible)));
+ return parts;
+}
+
+function getByRoleParts(call: CallArguments): ParsedSelectorPart[] {
+ checkArguments(call, 1, ['name', 'description', 'exact', 'checked', 'disabled', 'expanded', 'includeHidden', 'level', 'pressed', 'selected']);
+ const exact = !!option(call, 'exact', isBoolean);
+ let body = arg(call, 0, isString);
+ for (const name of call.options.keys()) {
+ if (name === 'name' || name === 'description')
+ body += `[${name}=${escapeForAttributeSelector(option(call, name, isText)!, exact)}]`;
+ else if (name === 'level')
+ body += `[level=${option(call, name, isNumber)}]`;
+ else if (name !== 'exact')
+ body += `[${name === 'includeHidden' ? 'include-hidden' : name}=${option(call, name, isBoolean)}]`;
+ }
+ return [selectorPart('internal:role', body)];
+}
+
+function selectorPart(name: string, body: string): ParsedSelectorPart {
+ return { name, body, source: body };
+}
+
+function nestedSelectorPart(name: string, parsed: ParsedSelector): ParsedSelectorPart {
+ return { name, body: { parsed }, source: JSON.stringify(stringifySelector(parsed)) };
+}
+
+function isNestedSelectorPart(part: ParsedSelectorPart): boolean {
+ return typeof part.body === 'object' && 'parsed' in part.body;
+}
+
+function checkArguments(call: CallArguments, maxArgs: number, allowedOptions: string[]) {
+ if (call.args.length > maxArgs)
+ throw new Error(`Too many arguments for ${call.method}`);
+ for (const name of call.options.keys()) {
+ if (!allowedOptions.includes(name))
+ throw new Error(`Unsupported option ${name} for ${call.method}`);
}
+}
- // Substitute params.
- return parts.map(t => {
- if (!t.startsWith('internal:') || t === 'internal:control')
- return t.replace(/\$(\d+)/g, (_, ordinal) => { const param = params[+ordinal - 1]; return param.text; });
- t = t.includes('[') ? t.replace(/\]/, '') + ']' : t;
- t = t
- .replace(/(?:r)\$(\d+)(i)?/g, (_, ordinal, suffix) => {
- const param = params[+ordinal - 1];
- if (t.startsWith('internal:attr') || t.startsWith('internal:testid') || t.startsWith('internal:role'))
- return escapeForAttributeSelector(new RegExp(param.text), false) + (suffix || '');
- return escapeForTextSelector(new RegExp(param.text, suffix), false);
- })
- .replace(/\$(\d+)(i|s)?/g, (_, ordinal, suffix) => {
- const param = params[+ordinal - 1];
- if (t.startsWith('internal:has=') || t.startsWith('internal:has-not='))
- return param.text;
- if (t.startsWith('internal:testid'))
- return escapeForAttributeSelector(param.text, true);
- if (t.startsWith('internal:attr') || t.startsWith('internal:role'))
- return escapeForAttributeSelector(param.text, suffix === 's');
- return escapeForTextSelector(param.text, suffix === 's');
- });
- return t;
- }).join(' >> ');
+function arg<T extends Value>(call: CallArguments, index: number, is: (value: Value) => value is T): T {
+ const value = call.args[index];
+ if (value === undefined || !is(value))
+ throw new Error(`Unexpected argument #${index} for ${call.method}`);
+ return value;
+}
+
+function option<T extends Value>(call: CallArguments, name: string, is: (value: Value) => value is T): T | undefined {
+ const value = call.options.get(name);
+ if (value !== undefined && !is(value))
+ throw new Error(`Unexpected ${name} option for ${call.method}`);
+ return value;
+}
+
+function isString(value: Value): value is string {
+ return typeof value === 'string';
+}
+
+function isText(value: Value): value is string | RegExp {
+ return typeof value === 'string' || value instanceof RegExp;
+}
+
+function isNumber(value: Value): value is number {
+ return typeof value === 'number';
+}
+
+function isBoolean(value: Value): value is boolean {
+ return typeof value === 'boolean';
+}
+
+function isSelector(value: Value): value is ParsedSelector {
+ return typeof value === 'object' && !(value instanceof RegExp);
+}
+
+function lowerFirst(identifier: string): string {
+ return identifier.charAt(0).toLowerCase() + identifier.substring(1);
}
export function locatorOrSelectorAsSelector(language: Language, locator: string, testIdAttributeName: string = 'data-testid'): string {
@@ -236,17 +649,8 @@ export function unsafeLocatorOrSelectorAsSelector(language: Language, locator: s
return locator;
} catch (e) {
}
- const { selector, preferredQuote } = parseLocator(locator, testIdAttributeName);
- const locators = asLocators(language, selector, undefined, undefined, preferredQuote);
- const digest = digestForComparison(language, locator);
- if (locators.some(candidate => digestForComparison(language, candidate) === digest))
- return selector;
- return '';
-}
-
-function digestForComparison(language: Language, locator: string) {
- locator = locator.replace(/\s/g, '');
- if (language === 'javascript')
- locator = locator.replace(/\\?["`]/g, '\'').replace(/,{}/g, '');
- return locator;
+ const Parser = parsers[language];
+ if (!Parser)
+ return '';
+ return stringifySelector(new Parser(locator, testIdAttributeName).parse());
}
diff --git a/tests/library/locator-generator.spec.ts b/tests/library/locator-generator.spec.ts
index 4476a8c265..dfdba4c472 100644
--- a/tests/library/locator-generator.spec.ts
+++ b/tests/library/locator-generator.spec.ts
@@ -611,6 +611,14 @@ it('asLocator internal:chain', async () => {
expect.soft(asLocator('csharp', 'div >> internal:chain="span >> article"')).toBe(`Locator("div").Locator(Locator("span").Locator("article"))`);
});
+it('parseLocator and, or, chain', async () => {
+ for (const kind of ['and', 'or', 'chain']) {
+ const selector = `div >> internal:${kind}="span >> article"`;
+ for (const lang of ['javascript', 'python', 'java', 'csharp'] as const)
+ expect.soft(parseLocator(lang, asLocator(lang, selector), 'data-testid'), lang).toBe(selector);
+ }
+});
+
it('asLocator xpath', async () => {
const selector = `//*[contains(normalizer-text(), 'foo']`;
expect.soft(asLocator('javascript', selector)).toBe(`locator('//*[contains(normalizer-text(), \\'foo\\']')`);
@@ -619,14 +627,14 @@ it('asLocator xpath', async () => {
expect.soft(asLocator('csharp', selector)).toBe(`Locator(\"//*[contains(normalizer-text(), 'foo']\")`);
expect.soft(parseLocator('javascript', `locator('//*[contains(normalizer-text(), \\'foo\\']')`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
expect.soft(parseLocator('javascript', `locator("//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
- expect.soft(parseLocator('javascript', `locator('xpath=//*[contains(normalizer-text(), \\'foo\\']')`, 'data-testid')).toBe("xpath=//*[contains(normalizer-text(), 'foo']");
- expect.soft(parseLocator('javascript', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("xpath=//*[contains(normalizer-text(), 'foo']");
+ expect.soft(parseLocator('javascript', `locator('xpath=//*[contains(normalizer-text(), \\'foo\\']')`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
+ expect.soft(parseLocator('javascript', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
expect.soft(parseLocator('python', `locator("//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
- expect.soft(parseLocator('python', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("xpath=//*[contains(normalizer-text(), 'foo']");
+ expect.soft(parseLocator('python', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
expect.soft(parseLocator('java', `locator("//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
- expect.soft(parseLocator('java', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("xpath=//*[contains(normalizer-text(), 'foo']");
+ expect.soft(parseLocator('java', `locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
expect.soft(parseLocator('csharp', `Locator("//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
- expect.soft(parseLocator('csharp', `Locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("xpath=//*[contains(normalizer-text(), 'foo']");
+ expect.soft(parseLocator('csharp', `Locator("xpath=//*[contains(normalizer-text(), 'foo']")`, 'data-testid')).toBe("//*[contains(normalizer-text(), 'foo']");
});
it('parseLocator quotes', async () => {
@@ -634,7 +642,7 @@ it('parseLocator quotes', async () => {
expect.soft(parseLocator('javascript', `locator("text='bar'")`, '')).toBe(`text='bar'`);
expect.soft(parseLocator('javascript', "locator(`text='bar'`)", '')).toBe(`text='bar'`);
expect.soft(parseLocator('python', `locator("text='bar'")`, '')).toBe(`text='bar'`);
- expect.soft(parseLocator('python', `locator('text="bar"')`, '')).toBe(``);
+ expect.soft(parseLocator('python', `locator('text="bar"')`, '')).toBe(`text="bar"`);
expect.soft(parseLocator('java', `locator("text='bar'")`, '')).toBe(`text='bar'`);
expect.soft(parseLocator('java', `locator('text="bar"')`, '')).toBe(``);
expect.soft(parseLocator('csharp', `Locator("text='bar'")`, '')).toBe(`text='bar'`);
@@ -650,13 +658,13 @@ it('parseLocator quotes', async () => {
it('parseLocator css', async () => {
expect.soft(parseLocator('javascript', `locator('.foo')`, '')).toBe(`.foo`);
- expect.soft(parseLocator('javascript', `locator('css=.foo')`, '')).toBe(`css=.foo`);
+ expect.soft(parseLocator('javascript', `locator('css=.foo')`, '')).toBe(`.foo`);
expect.soft(parseLocator('python', `locator(".foo")`, '')).toBe(`.foo`);
- expect.soft(parseLocator('python', `locator("css=.foo")`, '')).toBe(`css=.foo`);
+ expect.soft(parseLocator('python', `locator("css=.foo")`, '')).toBe(`.foo`);
expect.soft(parseLocator('java', `locator(".foo")`, '')).toBe(`.foo`);
- expect.soft(parseLocator('java', `locator("css=.foo")`, '')).toBe(`css=.foo`);
+ expect.soft(parseLocator('java', `locator("css=.foo")`, '')).toBe(`.foo`);
expect.soft(parseLocator('csharp', `Locator(".foo")`, '')).toBe(`.foo`);
- expect.soft(parseLocator('csharp', `Locator("css=.foo")`, '')).toBe(`css=.foo`);
+ expect.soft(parseLocator('csharp', `Locator("css=.foo")`, '')).toBe(`.foo`);
});
@@ -665,6 +673,108 @@ it('parseLocator options', async () => {
expect.soft(parseLocator('javascript', `getByRole('checkbox', { checked:false, includeHidden: true })`, '')).toBe(`internal:role=checkbox[checked=false][include-hidden=true]`);
});
+it('parseLocator role options', async () => {
+ expect.soft(parseLocator('python', `get_by_role("checkbox", checked=True, include_hidden=True)`, '')).toBe(`internal:role=checkbox[checked=true][include-hidden=true]`);
+ expect.soft(parseLocator('javascript', `getByRole('button', { nme: 'foo' })`, '')).toBe(``);
+});
+
+it('parseLocator round-trips selectors', async () => {
+ const selectors = [
+ 'div',
+ '.foo',
+ '//div',
+ 'internal:text="hello"i',
+ 'internal:text="hello"s',
+ 'internal:text=/he\\"llo/i',
+ 'internal:text=/a\\/b/',
+ 'internal:text=/a.b/ims',
+ 'internal:role=button[name=/a.b/ms]',
+ 'internal:text="a\'b\\"c`d"i',
+ 'internal:text="a\\\\b"i',
+ 'internal:text="tab\\there\\nnewline"i',
+ 'internal:text="\\u0001"i',
+ 'internal:label="x"s',
+ 'internal:label=/x/',
+ 'internal:attr=[placeholder="p"i]',
+ 'internal:attr=[alt="a"s]',
+ 'internal:attr=[title=/t/i]',
+ 'internal:testid=[data-testid="id"s]',
+ 'internal:testid=[data-testid=/id/]',
+ 'internal:role=button',
+ 'internal:role=button[name="ok"s]',
+ 'internal:role=button[name=/ok/i]',
+ 'internal:role=checkbox[checked=true][include-hidden=true]',
+ 'internal:role=heading[name="h"s][level=2]',
+ 'internal:role=alert[name="Upload"s][description="doc.pdf"s]',
+ 'internal:role=alert[name=/U/][description="d"i]',
+ 'internal:role=button[pressed=false][disabled=true][expanded=true][selected=true]',
+ 'div >> nth=0',
+ 'div >> nth=-1',
+ 'div >> nth=3',
+ 'div >> visible=true',
+ 'div >> visible=false',
+ 'div >> internal:has-text="foo"i >> span',
+ 'div >> internal:has-not-text=/foo/',
+ 'div >> internal:has="span >> internal:has=\\"b\\""',
+ 'div >> internal:has-not="internal:role=button[name=\\"x\\"i]"',
+ 'iframe >> internal:control=enter-frame >> div',
+ 'iframe >> nth=0 >> internal:control=enter-frame >> div',
+ 'internal:attr=[title="t"i] >> internal:control=enter-frame',
+ 'internal:control=any-frame >> div',
+ 'div >> internal:and="span >> nth=0"',
+ 'div >> internal:or="span"',
+ 'div >> internal:chain="span >> internal:has-text=\\"x\\"i"',
+ ];
+ for (const selector of selectors) {
+ for (const lang of ['javascript', 'python', 'java', 'csharp'] as const) {
+ const [canonical, ...alternatives] = asLocators(lang, selector);
+ expect.soft(parseLocator(lang, canonical, 'data-testid'), `${lang}: ${canonical}`).toBe(selector);
+ // Alternatives may parse into an equivalent selector, e.g. `css=div` instead of `div`.
+ for (const locator of alternatives)
+ expect.soft(asLocator(lang, parseLocator(lang, locator, 'data-testid')), `${lang}: ${locator}`).toBe(canonical);
+ }
+ }
+});
+
+it('reverse engineer regex flags', async () => {
+ expect.soft(generateForSelector('internal:text=/a.b/ims')).toEqual({
+ csharp: 'GetByText(new Regex("a.b", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline))',
+ java: 'getByText(Pattern.compile("a.b", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL))',
+ javascript: 'getByText(/a.b/ims)',
+ python: 'get_by_text(re.compile(r"a.b", re.IGNORECASE | re.MULTILINE | re.DOTALL))',
+ });
+ expect.soft(generateForSelector('internal:role=button[name=/a.b/s]')).toEqual({
+ csharp: 'GetByRole(AriaRole.Button, new() { NameRegex = new Regex("a.b", RegexOptions.Singleline) })',
+ java: 'getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName(Pattern.compile("a.b", Pattern.DOTALL)))',
+ javascript: `getByRole('button', { name: /a.b/s })`,
+ python: 'get_by_role("button", name=re.compile(r"a.b", re.DOTALL))',
+ });
+});
+
+it('parseLocator rejects malformed locators', async () => {
+ const locators = [
+ ['javascript', `locator('div').nth(0))`],
+ ['javascript', `locator('div').nth(-)`],
+ ['javascript', `locator('div')..locator('span')`],
+ ['javascript', `getByRole('button', { nme: 'ok' })`],
+ ['javascript', `getByRole('button', { name: 'ok', exct: true })`],
+ ['javascript', `getByText('foo', { exact: 'true' })`],
+ ['javascript', `locator('div').filter({ hasText: 'foo' }})`],
+ ['python', `get_by_role("checkbox", cheked=True)`],
+ ['python', `locator("div").filter(has_text=="foo")`],
+ ['python', `locator("div").nth(0))`],
+ ['java', `locator("div").filter(newLocator.FilterOptions().setHasText("foo"))`],
+ ['java', `getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setNme("ok"))`],
+ ['java', `locator('div')`],
+ ['csharp', `GetByTestId(newRegex("id"))`],
+ ['csharp', `GetByRole(AriaRole.Button, new() { Nme = "ok" })`],
+ ['csharp', `Locator('div')`],
+ ['csharp', `Locator("div").Nth(0))`],
+ ] as const;
+ for (const [lang, locator] of locators)
+ expect.soft(parseLocator(lang, locator, 'data-testid'), `${lang}: ${locator}`).toBe('');
+});
+
it('parse locators strictly', () => {
const selector = 'div >> internal:has-text=\"Goodbye world\"i >> span';
@@ -676,7 +786,7 @@ it('parse locators strictly', () => {
// Quotes
expect.soft(parseLocator('javascript', `locator("div").filter({ hasText: "Goodbye world" }).locator("span")`)).toBe(selector);
- expect.soft(parseLocator('python', `locator('div').filter(has_text='Goodbye world').locator('span')`)).not.toBe(selector);
+ expect.soft(parseLocator('python', `locator('div').filter(has_text='Goodbye world').locator('span')`)).toBe(selector);
// Whitespace
expect.soft(parseLocator('csharp', `Locator("div") . Filter (new ( ) { HasText = "Goodbye world" }).Locator( "span" )`)).toBe(selector);
@@ -689,19 +799,27 @@ it('parse locators strictly', () => {
expect.soft(parseLocator('java', `locator("div").filter(new Locator.FilterOptions().setHasText("Goodbye world"))..locator("span")`)).not.toBe(selector);
expect.soft(parseLocator('javascript', `locator('div').filter({ hasText: 'Goodbye world' }}).locator('span')`)).not.toBe(selector);
expect.soft(parseLocator('python', `locator("div").filter(has_text=="Goodbye world").locator("span")`)).not.toBe(selector);
+ expect.soft(parseLocator('javascript', `locator('div').nth(0))`)).toBe('');
});
it('parseLocator frames', async () => {
expect.soft(parseLocator('javascript', `locator('iframe').contentFrame().getByText('foo')`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
expect.soft(parseLocator('javascript', `frameLocator('iframe').getByText('foo')`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
- expect.soft(parseLocator('javascript', `frameLocator('css=iframe').getByText('foo')`, '')).toBe(`css=iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
+ expect.soft(parseLocator('javascript', `frameLocator('css=iframe').getByText('foo')`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
expect.soft(parseLocator('javascript', `getByTitle('iframe title').contentFrame()`)).toBe(`internal:attr=[title=\"iframe title\"i] >> internal:control=enter-frame`);
+ // FrameLocator.first() and nth() pick the frame element, so there is no locator for nth inside a frame.
+ const nthInsideFrame = 'iframe >> internal:control=enter-frame >> nth=1';
+ for (const lang of ['javascript', 'python', 'java', 'csharp'] as const) {
+ for (const locator of asLocators(lang, nthInsideFrame))
+ expect.soft(parseLocator(lang, locator), `${lang}: ${locator}`).not.toBe(nthInsideFrame);
+ }
+
expect.soft(asLocators('javascript', 'internal:attr=[title=\"iframe title\"i] >> internal:control=enter-frame')).toEqual([`getByTitle('iframe title').contentFrame()`]);
expect.soft(parseLocator('python', `locator("iframe").content_frame.get_by_text("foo")`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
expect.soft(parseLocator('python', `frame_locator("iframe").get_by_text("foo")`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
- expect.soft(parseLocator('python', `frame_locator("css=iframe").get_by_text("foo")`, '')).toBe(`css=iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
+ expect.soft(parseLocator('python', `frame_locator("css=iframe").get_by_text("foo")`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
expect.soft(parseLocator('csharp', `Locator("iframe").ContentFrame.GetByText("foo")`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);
expect.soft(parseLocator('csharp', `FrameLocator("iframe").GetByText("foo")`, '')).toBe(`iframe >> internal:control=enter-frame >> internal:text=\"foo\"i`);