11import { defaultLocalize , Enum } from '@enum-plus' ;
2- import { expect , test } from '../../e2e/fixtures/EnumTest' ;
2+ import type { Page } from '@playwright/test' ;
3+ import { expect , test } from '@playwright/test' ;
34import { getLocales , setLang } from '../data/week-config' ;
45import { deserializeJavascript , serializeJavascript } from '../utils/serialize-javascript' ;
56import TestEngineBase , { type RuntimeContext } from './base' ;
@@ -10,68 +11,97 @@ export class PlaywrightEngine extends TestEngineBase {
1011 super ( ) ;
1112 this . _type = 'playwright' ;
1213 }
14+ override describe ( name : string , fn : ( ) => void ) : void {
15+ test . describe ( name , fn ) ;
16+ }
1317
1418 override test < Data = unknown > (
1519 name : string ,
1620 evaluate : ( context : RuntimeContext ) => Data ,
1721 assert : ( data : Data ) => void ,
1822 evaluateContext ?: Record < string , unknown >
1923 ) : void {
20- const evaluateContextStr = serializeJavascript ( { ...evaluateContext , evaluateFn : evaluate } ) ;
21- test ( `${ name } , async ( { page } ) => {
22- const resultStr = await page . evaluate ( ( contextStr ) => {
23- const EnumPlus = window . EnumPlus ;
24- const WeekConfig = window . WeekConfig ;
25- const WeekData = window . WeekData ;
26- const SerializeJavascript = window . SerializeJavascript ;
27- const runtimeContext = {
28- EnumPlus,
29- WeekConfig,
30- WeekData,
31- SerializeJavascript,
32- } ;
33- // console.log('window', runtimeContext);
34- const { serializeJavascript : serialize , deserializeJavascript : deserialize } = SerializeJavascript ;
35- const args = deserialize ( contextStr ) as { evaluateFn : typeof evaluate } ;
36- const { evaluateFn, ...rest } = args ;
37- const evaluateResult = evaluateFn ( { ...runtimeContext , ...rest } ) ;
38- // console.log('evaluateResult');
39- // console.log(evaluateResult);
40- // save the current lang to the result
41- const serializedStr = serialize ( {
42- EnumLocalize : EnumPlus . Enum . localize ,
43- lang : WeekConfig . lang ,
44- ...evaluateResult ,
45- } ) ;
46- // console.log('serialize result');
47- // console.log(serializeResult);
48- return serializedStr ;
49- } , evaluateContextStr ) ;
24+ const serializedEvaluateParams = serializeJavascript ( { ...evaluateContext , evaluateFn : evaluate } ) ;
5025
51- const initialState = deserializeJavascript ( resultStr ) ;
52- // restore the lang to the Enum.localize
53- setLang ( initialState . lang , Enum , getLocales , defaultLocalize ) ;
54- if ( ! initialState . EnumLocalize ) {
55- Enum . localize = undefined ! ;
56- }
57- // the Enum object is used to "help" to access the Enum global function,
58- // because the code is like `const localize = this._options?.localize ?? Enum.localize;`,
59- // it seems that Enum is a global variable, but actually it is not, we simulate it as a closure context.
60- const testResult = deserializeJavascript ( resultStr , {
61- closure : { Enum, ...initialState } ,
62- } ) ;
63- // console.log('deserialize result');
64- // console.log(testResult);
65- assert ( testResult as Data ) ;
26+ // test(`(es) ${name}`, async ({ page }) => {
27+ // await page.goto('/modern.html', { waitUntil: 'domcontentloaded' });
28+ // await page.waitForLoadState('domcontentloaded');
29+ // await this.executeEvaluation({ page, assert, serializedEvaluateParams });
30+ // });
31+
32+ test ( `(es-legacy) ${ name } , async ( { page } ) => {
33+ await page . goto ( '/legacy.html' , { waitUntil : 'domcontentloaded' } ) ;
34+ await page . waitForLoadState ( 'domcontentloaded' ) ;
35+ await this . executeEvaluation ( { page, assert, serializedEvaluateParams } ) ;
6636 } ) ;
6737 }
38+
6839 // eslint-disable-next-line @typescript-eslint/ban-types
6940 override expect < ActualType = unknown > ( actual : ActualType ) : MakeMatchers < void , ActualType , { } > {
7041 // eslint-disable-next-line @typescript-eslint/ban-types
7142 return expect ( actual ) as unknown as MakeMatchers < void , ActualType , { } > ;
7243 }
73- override describe ( name : string , fn : ( ) => void ) : void {
74- test . describe ( name , fn ) ;
44+
45+ // Execute the test evaluation
46+ protected async executeEvaluation < Data = unknown > ( options : {
47+ page : Page ;
48+ assert : ( data : Data ) => void ;
49+ serializedEvaluateParams : string ;
50+ } ) {
51+ const { page, assert, serializedEvaluateParams } = options ;
52+ const resultStr = await page . evaluate ( ( contextStr ) => {
53+ const EnumPlus = window . EnumPlus ;
54+ const WeekConfig = window . WeekConfig ;
55+ const WeekData = window . WeekData ;
56+ const SerializeJavascript = window . SerializeJavascript ;
57+
58+ // Deserialize request
59+ const runtimeContext = {
60+ EnumPlus,
61+ WeekConfig,
62+ WeekData,
63+ SerializeJavascript,
64+ } ;
65+ // console.log('window', runtimeContext);
66+ const { serializeJavascript : serialize , deserializeJavascript : deserialize } = SerializeJavascript ;
67+ const args = deserialize ( contextStr ) as { evaluateFn : ( context : RuntimeContext ) => Data } ;
68+ const { evaluateFn, ...rest } = args ;
69+
70+ // Set the initial state to en-US before executing evaluation
71+ WeekConfig . setLang ( 'en-US' , EnumPlus . Enum , WeekConfig . getLocales , EnumPlus . defaultLocalize ) ;
72+
73+ // Execute the evaluation
74+ const evaluateResult = evaluateFn ( { ...runtimeContext , ...rest } ) ;
75+ // console.log('evaluateResult');
76+ // console.log(evaluateResult);
77+
78+ // Serialize the evaluation result and pass it to assertion method
79+ const serializedStr = serialize ( {
80+ EnumLocalize : EnumPlus . Enum . localize ,
81+ lang : WeekConfig . lang ,
82+ ...evaluateResult ,
83+ } ) ;
84+ // console.log('serialize result');
85+ // console.log(serializeResult);
86+ return serializedStr ;
87+ } , serializedEvaluateParams ) ;
88+
89+ const initialState = deserializeJavascript ( resultStr , { debug : true , prettyPrint : false } ) ;
90+ // Restore the lang to the Enum.localize
91+ setLang ( initialState . lang , Enum , getLocales , defaultLocalize ) ;
92+ if ( ! initialState . EnumLocalize ) {
93+ Enum . localize = undefined ! ;
94+ }
95+
96+ // the Enum object is used to "help" to access the Enum global function,
97+ // because the code is like `const localize = this._options?.localize ?? Enum.localize;`,
98+ // it seems that Enum is a global variable, but actually it is not, we simulate it as a closure context.
99+ const testResult = deserializeJavascript ( resultStr , {
100+ closure : { Enum, ...initialState } ,
101+ } ) ;
102+ // console.log('deserialize result');
103+ // console.log(testResult);
104+ assert ( testResult as Data ) ;
75105 }
76106}
77107
0 commit comments