jest.setup.js

/*!
 * Rigging for the WikiLambda browser jest UX unit testing suite
 *
 * @copyright 2020– Abstract Wikipedia team; see AUTHORS.txt
 * @license MIT
 */
'use strict';

/* global jest, mockLocalStorage, mockSessionStorage, $ */
// Assign things to "global" here if you want them to be globally available during tests
const fs = require( 'fs' );
const path = require( 'path' );
// eslint-disable-next-line n/no-unsupported-features/node-builtins
const { webcrypto } = require( 'node:crypto' );
const vueTestUtils = require( '@vue/test-utils' );
const { createTestingPinia } = require( '@pinia/testing' );
const Constants = require( './resources/ext.wikilambda.app/Constants.js' );

// Use Node's webcrypto for Web Crypto API in tests
// jsdom provides crypto but without subtle, so we replace it with webcrypto
Object.defineProperty( global, 'crypto', { value: webcrypto, writable: true, configurable: true } );

// jsdom usually has TextEncoder nowadays, but just in case:
if ( !global.TextEncoder ) {
	const { TextEncoder } = require( 'node:util' );
	global.TextEncoder = TextEncoder;
}

global.$ = require( 'jquery' );

global.mockLocalStorage = {};
global.mockSessionStorage = {};

global.toQueryParam = function ( param ) {
	return Object.keys( param )
		.map( ( key ) => key + '=' + param[ key ] )
		.join( '&' );
};

function Api() {}
Api.prototype.get = jest.fn().mockReturnValue( $.Deferred().resolve().promise() );

function ForeignApi() {}
ForeignApi.prototype.get = jest.fn().mockReturnValue( $.Deferred().resolve().promise() );

// Jest uses jsdom which is in incomplete mock of browser API, inclduing no scrollIntoView()
// thatis used by Codex; make sure it doesn't trigger fatals.
// eslint-disable-next-line no-undef
Element.prototype.scrollIntoView = jest.fn();

class Title {
	constructor( page ) {
		this.page = page;
	}

	getUrl( param ) {
		if ( param && Object.keys( param ).length > 0 ) {
			param.title = this.page;
			return Constants.PATHS.ROUTE_FORMAT_ONE + '?' + global.toQueryParam( param );
		}

		return Constants.PATHS.ROUTE_FORMAT_TWO + this.page;
	}
}

const upstreami18n = {
	'colon-separator': ': ',
	'comma-separator': ', ',
	parentheses: '($1)',
	'quotation-marks': '"$1"'
};
const baseEnglishMessages = JSON.parse( fs.readFileSync( path.join( __dirname, './i18n/en.json' ) ) );
const englishVeMessages = JSON.parse( fs.readFileSync( path.join( __dirname, './i18n/ve/en.json' ) ) );
const englishAbstractMessages = JSON.parse( fs.readFileSync( path.join( __dirname, './i18n/abstract/en.json' ) ) );
const englishApiMessages = JSON.parse( fs.readFileSync( path.join( __dirname, './i18n/api/en.json' ) ) );
const englishApiAbstractMessages = JSON.parse( fs.readFileSync( path.join( __dirname, './i18n/api/abstract/en.json' ) ) );
const englishMessages = Object.assign(
	{},
	baseEnglishMessages,
	englishVeMessages,
	englishAbstractMessages,
	englishApiMessages,
	englishApiAbstractMessages,
	upstreami18n
);

class Mocki18n {
	constructor( string, ...params ) {
		this.string = string;
		this.paramsList = params;
	}

	interpolate( str ) {
		if ( !str ) {
			return '';
		}
		if ( this.paramsList.length ) {
			let interpolated = str;
			this.paramsList.forEach( ( param, index ) => {
				interpolated = interpolated.replace( new RegExp( `\\$${ index + 1 }`, 'g' ), param );
			} );
			return interpolated;
		}
		return str;
	}

	text() {
		return this.interpolate( englishMessages[ this.string ] );
	}

	escaped() {
		return this.interpolate( englishMessages[ this.string ] ).replace( /"/g, '"' );
	}

	toString() {
		return this.text();
	}

	params() {
		return this;
	}

	parse() {
		return this.text();
	}
}

// Stable Test Kitchen instrument stub, shared across getInstrument() calls so
// tests can assert on the same submitInteraction mock.
const testKitchenInstrument = {
	submitInteraction: jest.fn( ( action, interactionData ) => {

		console.log( 'Test Kitchen event emitted using submitInteraction: ' + action + ' - ' + JSON.stringify( interactionData ) );
	} ),
	send: jest.fn(),
	setSchemaID: jest.fn()
};

// Mock MW object
global.mw = {
	Api: Api,
	ForeignApi: ForeignApi,
	config: {
		get: jest.fn( ( endpoint ) => {
			switch ( endpoint ) {
				case 'wgWikiLambda':
					return {
						createNewPage: true,
						viewmode: true,
						zobject: { Z1K1: 'Z2', Z2K1: 'Z0' },
						zlangZid: 'Z1002',
						zlang: 'en'
					};
				case 'wgWikifunctionsBaseUrl':
					return null;
				case 'wgWikiLambdaAbstractPrimaryNamespace':
					return 'Abstract_Wikipedia';
				case 'wgWikiLambdaSuggestedFunctions':
				case 'wgWikiLambdaAbstractSuggestions':
					return [];
				case 'wgUserLanguage':
					return 'en';
				case 'wgPageContentLanguage':
					return 'en';
				default:
					return null;
			}
		} ),
		values: {
			wgUserName: 'username'
		}
	},
	user: {
		isAnon: jest.fn().mockReturnValue( true ),
		getRights: jest.fn().mockReturnValue( {
			then: jest.fn().mockReturnValue( [] )
		} )
	},
	language: {
		getFallbackLanguageChain: function () {
			return [ 'en' ];
		},
		listToText: function () {
			return 'list';
		},
		convertNumber: function ( num ) {
			// Simple mock implementation: format numbers with comma separators
			return new Intl.NumberFormat( 'en-US' ).format( num );
		}
	},
	storage: {
		get: jest.fn( ( key ) => mockLocalStorage[ key ] ),
		set: jest.fn( ( key, value ) => {
			mockLocalStorage[ key ] = value;
		} ),
		session: {
			get: jest.fn( ( key ) => mockSessionStorage[ key ] || null ),
			set: jest.fn( ( key, value ) => {
				mockSessionStorage[ key ] = value;
			} ),
			remove: jest.fn( ( key ) => {
				delete mockSessionStorage[ key ];
			} )
		}
	},
	track: jest.fn( ( trackkey, trackmessage ) => {

		console.log( 'Log emitted: ' + trackkey + ' - ' + trackmessage );
	} ),
	testKitchen: {
		getInstrument: jest.fn( () => testKitchenInstrument )
	},
	message: jest.fn( ( str, ...params ) => new Mocki18n( str, ...params ) ),
	msg: jest.fn( ( str, ...params ) => new Mocki18n( str, ...params ) ),
	Uri: jest.fn().mockReturnValue( {
		path: jest.fn(),
		query: jest.fn()
	} ),
	Title: Title

	// other mw properties as needed...
};

// Mock i18n & store for all tests
global.$i18n = jest.fn( ( str, ...params ) => new Mocki18n( str, ...params ) );

vueTestUtils.config.global.mocks = {
	$i18n: global.$i18n
};

vueTestUtils.config.global.provide = {
	i18n: global.$i18n // This makes inject('i18n') work in Composition API tests
};

vueTestUtils.config.global.directives = {
	'i18n-html': ( el, binding ) => {
		el.innerHTML = global.mw.message( binding.arg, binding.value ).parse();
	}
};

global.store = createTestingPinia();
vueTestUtils.config.global.plugins = [ global.store ];

// Suppress Test Kitchen event logs
const originalLog = console.log;
console.log = function ( ...args ) {
	if (
		typeof args[ 0 ] === 'string' &&
			args[ 0 ].startsWith( 'Test Kitchen event emitted using submitInteraction' )
	) {
		return; // Suppress this log
	}
	originalLog.apply( console, args );
};