6 | console.{{ step.logEntry.type }}
7 | {{ step.logEntry.args }}
8 |
9 |
10 |
11 |
22 |
23 |
33 |
34 |
35 |
--------------------------------------------------------------------------------
/lib/api/script.js:
--------------------------------------------------------------------------------
1 | const { event } = require('codeceptjs');
2 | const codeceptjsFactory = require('../model/codeceptjs-factory');
3 |
4 | const { codecept, container } = codeceptjsFactory.getInstance({}, {
5 | grep: 'Create a new todo item'
6 | });
7 |
8 | const mocha = container.mocha();
9 | mocha.grep('Create a new todo item');
10 |
11 | // run bootstrap function from config
12 | codecept.runBootstrap();
13 |
14 | // process.chdir(TestProjectDir);
15 |
16 | codecept.run();
17 |
18 | event.dispatcher.once(event.all.result, () => {
19 | mocha.unloadFiles();
20 | mocha.suite.cleanReferences();
21 | mocha.suite.suites = [];
22 | codecept.run();
23 | });
24 |
25 |
--------------------------------------------------------------------------------
/lib/api/get-snapshot-html.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:get-snapshot-html');
2 | const snapshotStore = require('../model/snapshot-store');
3 |
4 | module.exports = (req, res) => {
5 | const { id } = req.params;
6 |
7 | if (!snapshotStore.exists(id)) {
8 | debug(`step ${id} does not exist`);
9 | res.status(404).send(`A snapshot for this step (${id}) does not exist`);
10 | return;
11 | }
12 | if (!snapshotStore.hasSnapshot(id)) {
13 | debug(`step ${id} does not have a snapshot`);
14 | res.status(404).send(`No snapshot for step id ${id}`);
15 | return;
16 | }
17 |
18 | const source = snapshotStore.get(id).source;
19 |
20 | res.send(source);
21 | };
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | #### What are you trying to achieve?
2 |
3 | - Provide a descriptive text that what you are trying to achieve with CodeceptUI.
4 | - Attach a screenshot should be more than welcome.
5 | - Provide a console output for frontend (open DevTools and copy or make a screenshot of last messages)
6 | - Provide output for backend (copy last mesage from terminal)
7 |
8 | #### What do you get instead?
9 |
10 | > Provide console output if related.
11 |
12 | ```bash
13 | # paste output here
14 | ```
15 |
16 | > Provide test source code if related
17 |
18 | ```js
19 | // paste test source code here
20 | ```
21 |
22 | ### Environment info
23 |
24 | - Copy and paste your environment info by using `npx codeceptjs info`
25 |
26 | ```js
27 | // paste env info here
28 | ```
29 |
--------------------------------------------------------------------------------
/lib/model/open-in-editor.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:open-in-editor');
2 | const { execSync } = require('child_process');
3 | const { getSettings } = require('./settings-repository');
4 |
5 | const openVSCode = fileName => {
6 | const { editor } = getSettings();
7 | return execSync(`${editor} "${fileName}"`, (err) => {
8 | if (!err) return 'Ok';
9 | console.error('Failed to open editor: ', err.toString()); // eslint-disable-line
10 | console.error(`Please, update your settings. Current editor command: ${editor}`); // eslint-disable-line
11 | debug(`Failed to open Editor - ${err}`);
12 | return `${err}`;
13 | });
14 | };
15 |
16 | module.exports = fileName => {
17 | // TODO Make this configurable
18 | openVSCode(fileName);
19 | };
20 |
--------------------------------------------------------------------------------
/src/components/steps/WaiterStep.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 | {{ formatStep(step.humanized) }}
4 |
5 |
10 |
11 | {{ step && step.returnValue }}
12 |
13 |
14 |
15 |
16 |
36 |
37 |
39 |
40 |
41 |
--------------------------------------------------------------------------------
/lib/api/list-steps.js:
--------------------------------------------------------------------------------
1 | const { getUrl } = require('../config/url');
2 | const { event } = require('codeceptjs');
3 | const codeceptjsFactory = require('../model/codeceptjs-factory');
4 |
5 | const WS_URL = getUrl('ws');
6 | const TestProjectDir = process.cwd();
7 |
8 |
9 | module.exports = async (req, res) => {
10 | const socket = require('socket.io-client')(WS_URL);
11 |
12 | const { scenario } = req.params;
13 | const { codecept, container } = codeceptjsFactory.getInstance();
14 |
15 | const mocha = container.mocha();
16 | mocha.grep(scenario);
17 |
18 | process.chdir(TestProjectDir);
19 |
20 | event.dispatcher.once(event.all.result, () => {
21 | mocha.unloadFiles();
22 | mocha.suite.cleanReferences();
23 | mocha.suite.suites = [];
24 | socket.emit('codeceptjs.exit', process.exitCode);
25 | });
26 |
27 | codecept.run();
28 |
29 | res.status(200).send('OK');
30 | };
31 |
32 |
--------------------------------------------------------------------------------
/lib/api/store-settings.js:
--------------------------------------------------------------------------------
1 | const codeceptjsFactory = require('../model/codeceptjs-factory');
2 | const { storeSettings } = require('../model/settings-repository');
3 | const setBrowser = require('../codeceptjs/configure/setBrowser');
4 | const { setHeadlessWhen, setWindowSize, setHeadedWhen } = require('@codeceptjs/configure');
5 |
6 | module.exports = (req, res) => {
7 | const settings = req.body || {};
8 | const { isHeadless, windowSize, browser, editor, isSingleSession } = settings;
9 |
10 | codeceptjsFactory.reloadConfig(() => {
11 | setHeadlessWhen(isHeadless === true);
12 | setHeadedWhen(isHeadless === false);
13 | if (browser) setBrowser(browser);
14 | if (windowSize && windowSize.width && windowSize.height) {
15 | setWindowSize(windowSize.width, windowSize.height);
16 | }
17 | });
18 |
19 | storeSettings({ editor, isSingleSession });
20 |
21 | res.json({
22 | message: 'Settings stored'
23 | });
24 | };
25 |
26 |
--------------------------------------------------------------------------------
/lib/model/testrun-repository.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:testRunRepository');
2 | const fs = require('fs');
3 | const path = require('path');
4 | const mkdir = require('../utils/mkdir');
5 |
6 | mkdir(path.join(global.output_dir, '.ui'));
7 | const TestRunBaseDir = path.join(global.output_dir, '.ui', 'testruns');
8 | mkdir(TestRunBaseDir);
9 |
10 | const fileNameFromId = id => `${encodeURIComponent(id)}.json`;
11 |
12 | module.exports = {
13 | saveTestRun(id, testRun) {
14 | debug(`Saving testrun ${id}`);
15 | fs.writeFileSync(path.join(TestRunBaseDir, fileNameFromId(id)), JSON.stringify(testRun), 'utf8');
16 | },
17 |
18 | getTestRun(id) {
19 | const testRunFile = path.join(TestRunBaseDir, fileNameFromId(id));
20 | if (!fs.existsSync(testRunFile)) return;
21 |
22 | debug(`Retrieving testrun ${id}`);
23 | const testRunAsString = fs.readFileSync(testRunFile);
24 | return JSON.parse(testRunAsString);
25 | }
26 | };
--------------------------------------------------------------------------------
/lib/api/run-scenario-parallel.js:
--------------------------------------------------------------------------------
1 | const os = require('os');
2 | const debug = require('debug')('codeceptjs:run-scenario-multiple');
3 | const wsEvents = require('../model/ws-events');
4 | const { event } = require('codeceptjs');
5 | const codeceptjsFactory = require('../model/codeceptjs-factory');
6 | const runWithWorkers = require('../model/codeceptjs-run-workers');
7 |
8 | module.exports = async (req, res) => {
9 | const { grep } = req.params;
10 | const numberOfWorkers = os.cpus().length;
11 |
12 | const { config, codecept, container } = codeceptjsFactory.getInstance();
13 |
14 | event.dispatcher.once(event.all.after, () => {
15 | debug('testrun finished');
16 | try {
17 | codeceptjsFactory.resetSuites();
18 | } catch (err) {
19 | debug('ERROR resetting suites', err);
20 | }
21 | wsEvents.codeceptjs.exit(0);
22 | });
23 |
24 | debug('Running with workers...');
25 | runWithWorkers(numberOfWorkers, config.get(), { grep }, codecept, container);
26 |
27 | return res.status(200).send('OK');
28 | };
29 |
--------------------------------------------------------------------------------
/src/components/steps/AssertionStep.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
7 |
11 |
12 | {{ formatStep(step.humanized) }}
13 |
14 |
15 |
5 |
35 |
36 |
37 |
53 |
58 |
--------------------------------------------------------------------------------
/src/components/pages/SettingsPage.vue:
--------------------------------------------------------------------------------
1 |
2 | 6 | {{ step.name }} 7 | 11 | {{ step.args[0] }} 12 | 13 |
14 | 15 |
19 |
24 |
25 | Request
20 |
21 | {{ JSON.stringify(step.args[1], null, 2) }}
22 |
23 |
29 |
34 | Response
30 |
31 | {{ JSON.stringify(step.returnValue, null, 2) }}
32 |
33 |
4 |
10 | Edit Config
11 |
12 |
22 | 13 | Configuration: {{ config.file }} 14 |
15 |
19 |
21 |
3 |
7 |
8 | {{ actorFromMetaStep(step) }}
9 |
10 |
11 | {{ methodFromMetaStep(step) }}
12 |
13 |
14 |
15 |
16 |
48 |
49 |
61 |
62 |
63 |
--------------------------------------------------------------------------------
/src/components/steps/Argument.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
10 | {{ trim(test.error.message) }}
11 |
12 |
19 |
27 |
28 |
29 |
47 |
48 |
76 |
--------------------------------------------------------------------------------
/lib/api/run-scenario.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:run-scenario');
2 | const wsEvents = require('../model/ws-events');
3 | const { event } = require('codeceptjs');
4 | const codeceptjsFactory = require('../model/codeceptjs-factory');
5 |
6 | module.exports = async (req, res) => {
7 | let { id, grep } = req.params;
8 | const { codecept, container } = codeceptjsFactory.getInstance();
9 |
10 | const mocha = container.mocha();
11 | mocha.grep(); // disable current grep
12 |
13 | if (id) {
14 | mocha.suite.eachTest(test => {
15 | if (test.uid === decodeURIComponent(id)) {
16 | test.parent.appendOnlyTest(test);
17 | }
18 | });
19 |
20 | event.dispatcher.once(event.suite.before, suite => {
21 | suite._onlyTests = [];
22 | });
23 | }
24 |
25 | if (grep) {
26 | mocha.fgrep(grep);
27 | }
28 |
29 | event.dispatcher.once(event.all.result, () => {
30 | mocha.grep(); // disable grep
31 | debug('testrun finished');
32 | try {
33 | codeceptjsFactory.reloadSuites();
34 | } catch (err) {
35 | debug('ERROR resetting suites', err);
36 | }
37 | wsEvents.codeceptjs.exit(0);
38 | });
39 |
40 | debug('codecept.run()');
41 |
42 | const done = () => {
43 | event.emit(event.all.result, codecept);
44 | event.emit(event.all.after, codecept);
45 | };
46 |
47 | try {
48 | event.emit(event.all.before, codecept);
49 | wsEvents.codeceptjs.started({ timestamp: new Date().toISOString() });
50 | global.runner = mocha.run(done);
51 | } catch (e) {
52 | throw new Error(e);
53 | }
54 |
55 | return res.status(200).send('OK');
56 | };
57 |
--------------------------------------------------------------------------------
/lib/api/stop.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:stop-scenario');
2 | const wsEvents = require('../model/ws-events');
3 | const { event } = require('codeceptjs');
4 |
5 | module.exports = async (req, res) => {
6 | debug('Stopping test execution');
7 |
8 | try {
9 | if (global.runner) {
10 | debug('Aborting active runner');
11 | global.runner.abort();
12 |
13 | // Set a timeout to ensure we don't wait forever
14 | const timeout = setTimeout(() => {
15 | debug('Stop timeout reached, forcing exit event');
16 | wsEvents.codeceptjs.exit(-1);
17 | global.runner = null;
18 | }, 5000); // 5 second timeout
19 |
20 | // Ensure we properly signal test completion and reset running state
21 | event.dispatcher.once(event.all.result, () => {
22 | clearTimeout(timeout);
23 | if (global.runner) {
24 | global.runner._abort = false;
25 | }
26 | global.runner = null;
27 | debug('Test runner stopped and reset');
28 | // Emit exit event to reset frontend running state
29 | wsEvents.codeceptjs.exit(-1); // -1 indicates stopped by user
30 | });
31 | } else {
32 | // If no runner is active, still emit exit event to reset frontend state
33 | debug('No active runner found, resetting state');
34 | wsEvents.codeceptjs.exit(-1);
35 | }
36 |
37 | return res.status(200).send('OK');
38 | } catch (error) {
39 | debug('Error stopping test execution:', error);
40 | // Always emit exit event to reset state even if there's an error
41 | wsEvents.codeceptjs.exit(-1);
42 | return res.status(500).send('Failed to stop execution');
43 | }
44 | };
45 |
--------------------------------------------------------------------------------
/src/components/RuntimeModeIndicator.vue:
--------------------------------------------------------------------------------
1 |
2 |
13 | {{ test.error.stack }}
14 |
15 |
16 |
17 | {{ trim(test.error.toString()) }}
18 |
3 |
8 |
13 |
17 | {{ modeText }}
18 |
19 |
20 |
21 |
22 |
23 |
56 |
57 |
--------------------------------------------------------------------------------
/test/cors-config.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const { spawn } = require('child_process');
3 | const path = require('path');
4 |
5 | test('Socket.IO server includes CORS configuration', (t) => {
6 | const binPath = path.join(__dirname, '..', 'bin', 'codecept-ui.js');
7 | const fs = require('fs');
8 | const binContent = fs.readFileSync(binPath, 'utf8');
9 |
10 | // Check that CORS configuration is present
11 | t.true(binContent.includes('cors:'), 'CORS configuration should be present');
12 | t.true(binContent.includes('origin:'), 'CORS origin should be configurable');
13 | t.true(binContent.includes('credentials: true'), 'CORS credentials should be enabled');
14 | t.true(binContent.includes('allowEIO3: true'), 'EIO3 compatibility should be enabled');
15 | });
16 |
17 | test('CORS origin defaults to application port', (t) => {
18 | const binPath = path.join(__dirname, '..', 'bin', 'codecept-ui.js');
19 | const fs = require('fs');
20 | const binContent = fs.readFileSync(binPath, 'utf8');
21 |
22 | // Check that default CORS origin uses application port
23 | t.true(binContent.includes('getPort(\'application\')'), 'Should use application port for default CORS origin');
24 | });
25 |
26 | test('CORS origin can be overridden via environment variable', (t) => {
27 | process.env.CORS_ORIGIN = 'http://example.com:3000';
28 |
29 | const binPath = path.join(__dirname, '..', 'bin', 'codecept-ui.js');
30 | const fs = require('fs');
31 | const binContent = fs.readFileSync(binPath, 'utf8');
32 |
33 | // Check that CORS_ORIGIN environment variable is used
34 | t.true(binContent.includes('process.env.CORS_ORIGIN'), 'Should check CORS_ORIGIN environment variable');
35 |
36 | delete process.env.CORS_ORIGIN;
37 | });
--------------------------------------------------------------------------------
/lib/api/list-actions.js:
--------------------------------------------------------------------------------
1 | function _interopDefault(ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex.default : ex; }
2 | const acorn = require('acorn');
3 | const parser = _interopDefault(require('parse-function'))({ parse: acorn.parse, ecmaVersion: 11 });
4 | const debug = require('debug')('codeceptjs:codeceptjs-factory');
5 | const fs = require('fs');
6 | const path = require('path');
7 | const codeceptjsFactory = require('../model/codeceptjs-factory');
8 | const { methodsOfObject } = require('codeceptjs/lib/utils');
9 |
10 | module.exports = (req, res) => {
11 | const { container } = codeceptjsFactory.getInstance();
12 | const docsWebApiFolderPath = path.join(path.dirname(require.resolve('codeceptjs')), '/../docs/webapi');
13 | const docFileList = [];
14 | try {
15 | fs.readdirSync(docsWebApiFolderPath).map(fileName => {
16 | docFileList.push(path.basename(fileName,'.mustache'));
17 | });
18 | } catch (e) {
19 | debug(`No documentation found due to ${e.message}`);
20 | }
21 | const helpers = container.helpers();
22 | const actions = {};
23 | for (const name in helpers) {
24 | const helper = helpers[name];
25 | methodsOfObject(helper).forEach((action) => {
26 |
27 | if (docFileList.includes(action)) {
28 | let filePath = path.join(docsWebApiFolderPath, action + '.mustache');
29 | let fn = helper[action].toString().replace(/\n/g, ' ').replace(/\{.*\}/gm, '{}');
30 | try {
31 | let docData = fs.readFileSync(filePath, 'utf-8');
32 | let params = parser.parse(fn);
33 | actions[action] = { params: params, actionDoc: docData };
34 | } catch (err) {
35 | debug('Error in fetching doc for file content', fn, err);
36 | }
37 | }
38 | });
39 | }
40 | res.send({ actions });
41 | };
42 |
--------------------------------------------------------------------------------
/lib/model/snapshot-store/index.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:snapshot-store');
2 | const assert = require('assert');
3 | const fs = require('fs');
4 | const path = require('path');
5 |
6 | const fixHtmlSnapshot = require('./fix-html-snapshot');
7 |
8 | const SnapshotBaseDir = path.join(global.output_dir || process.cwd(), '.ui', 'testruns');
9 |
10 | const fixSnapshot = snapshot => {
11 | if (snapshot && snapshot.sourceContentType === 'html') {
12 | snapshot = fixHtmlSnapshot(snapshot);
13 | }
14 | return snapshot;
15 | };
16 |
17 | const fileNameFromId = id => `${id}.snapshots.json`;
18 |
19 | module.exports = new class SnapshotStore {
20 | constructor() {
21 | this.steps = {};
22 | }
23 |
24 | clear() {
25 | this.steps = {};
26 | }
27 |
28 | add(id, snapshot) {
29 | assert(id, 'step id is required');
30 | assert(snapshot, 'snapshot is required');
31 |
32 | debug(`Adding step ${id}`);
33 |
34 | this.steps[id] = fixSnapshot(snapshot);
35 | }
36 |
37 | get(id) {
38 | return this.steps[id];
39 | }
40 |
41 | exists(id) {
42 | return this.steps[id] !== undefined;
43 | }
44 |
45 | hasSnapshot(id) {
46 | return this.exists(id) && this.get(id);
47 | }
48 |
49 | saveWithTestRun(testRunId) {
50 | const snapshotFile = path.join(SnapshotBaseDir, fileNameFromId(testRunId));
51 |
52 | debug(`Saving snapshots to ${snapshotFile}`);
53 |
54 | fs.writeFileSync(snapshotFile, JSON.stringify(this.steps), 'utf8');
55 | }
56 |
57 | restoreFromTestRun(testRunId) {
58 | const snapshotFile = path.join(SnapshotBaseDir, fileNameFromId(testRunId));
59 | if (!fs.existsSync(snapshotFile)) return;
60 |
61 | debug(`Retrieving snapshot for testrun ${testRunId}`);
62 | const snapshotData = fs.readFileSync(snapshotFile);
63 | this.steps = JSON.parse(snapshotData);
64 | }
65 | };
66 |
--------------------------------------------------------------------------------
/test/reverse-proxy.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const fs = require('fs');
3 | const path = require('path');
4 |
5 | test('Frontend handles reverse proxy configuration', (t) => {
6 | const mainJsPath = path.join(__dirname, '..', 'src', 'main.js');
7 | const mainJsContent = fs.readFileSync(mainJsPath, 'utf8');
8 |
9 | // Check that reverse proxy detection is present
10 | t.true(mainJsContent.includes('isReverseProxy'), 'Should detect reverse proxy setup');
11 | t.true(mainJsContent.includes('window.location.pathname !== \'/\''), 'Should check for non-root path');
12 |
13 | // Check that fallback handling is present
14 | t.true(mainJsContent.includes('catch (err)'), 'Should have fallback error handling');
15 | t.true(mainJsContent.includes('baseUrl.replace(\'http\', \'ws\')'), 'Should use WebSocket protocol conversion');
16 | });
17 |
18 | test('Frontend uses relative paths for reverse proxy', (t) => {
19 | const mainJsPath = path.join(__dirname, '..', 'src', 'main.js');
20 | const mainJsContent = fs.readFileSync(mainJsPath, 'utf8');
21 |
22 | // Check that relative API calls are used
23 | t.true(mainJsContent.includes('\'/api/ports\''), 'Should use relative API path');
24 | t.false(mainJsContent.includes('window.location.port'), 'Should not hardcode current port in API calls');
25 | });
26 |
27 | test('Port API endpoint returns correct format', (t) => {
28 | const apiIndexPath = path.join(__dirname, '..', 'lib', 'api', 'index.js');
29 | const apiContent = fs.readFileSync(apiIndexPath, 'utf8');
30 |
31 | // Check that ports endpoint exists and returns correct structure
32 | t.true(apiContent.includes('router.get(\'/ports\''), 'Ports endpoint should exist');
33 | t.true(apiContent.includes('port: getPort(\'application\')'), 'Should return application port');
34 | t.true(apiContent.includes('wsPort: getPort(\'ws\')'), 'Should return WebSocket port');
35 | });
--------------------------------------------------------------------------------
/lib/model/snapshot-store/fix-htmls-snapshot.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const fixHtmlSnapshot = require('./fix-html-snapshot');
3 |
4 | const makeHtml = snippet => {
5 | return `${snippet}`;
6 | };
7 |
8 | test('Relative Url: same resource', (t) => {
9 | const pageUrl = 'http://foo/some/path';
10 | const fixedSnapshot = fixHtmlSnapshot({
11 | pageUrl,
12 | source: makeHtml('')
13 | });
14 | t.is(fixedSnapshot.source, makeHtml(''));
15 | });
16 |
17 | test('Relative Url: same protocol', (t) => {
18 | const pageUrl = 'http://www.check24-test.de';
19 | const fixedSnapshot = fixHtmlSnapshot({
20 | pageUrl,
21 | source: makeHtml('')
22 | });
23 | t.is(fixedSnapshot.source, makeHtml(''));
24 | });
25 |
26 | test('Relative Url: same domain', (t) => {
27 | const pageUrl = 'http://foo:1234';
28 | const fixedSnapshot = fixHtmlSnapshot({
29 | pageUrl,
30 | source: makeHtml('')
31 | });
32 | t.is(fixedSnapshot.source, makeHtml(''));
33 | });
34 |
35 | test('script tags are removed', (t) => {
36 | const pageUrl = 'http://foo:1234';
37 | const fixedSnapshot = fixHtmlSnapshot({
38 | pageUrl,
39 | source: makeHtml('')
40 | });
41 | t.is(fixedSnapshot.source, makeHtml(''));
42 | });
--------------------------------------------------------------------------------
/lib/api/new-test.js:
--------------------------------------------------------------------------------
1 | const debug = require('debug')('codeceptjs:run-scenario');
2 | const wsEvents = require('../model/ws-events');
3 | const pause = require('../codeceptjs/brk');
4 | const { event } = require('codeceptjs');
5 | const { createTest } = require('codeceptjs/lib/mocha/test');
6 | const { createSuite } = require('codeceptjs/lib/mocha/suite');
7 | const codeceptjsFactory = require('../model/codeceptjs-factory');
8 |
9 | module.exports = async (req, res) => {
10 | const { codecept, container } = codeceptjsFactory.getInstance();
11 |
12 | const mocha = container.mocha();
13 | mocha.grep();
14 | mocha.files = [];
15 | mocha.suite.suites = [];
16 |
17 | const code = eval(req.body.code);
18 | const test = createTest('new test', code);
19 | test.uid = 'new-test';
20 |
21 | const suite = createSuite(mocha.suite, 'new test');
22 |
23 | let pauseEnabled = true;
24 |
25 | // Note: In CodeceptJS 3.x, the scenario setup/teardown methods may have changed
26 | // For now, we'll keep the basic structure and let the framework handle setup
27 |
28 | suite.addTest(test);
29 | suite.appendOnlyTest(test);
30 |
31 | event.dispatcher.once(event.test.after, () => {
32 | if (pauseEnabled) pause();
33 | });
34 |
35 | event.dispatcher.once(event.all.result, () => {
36 | pauseEnabled = false;
37 | debug('testrun finished');
38 | try {
39 | codeceptjsFactory.reloadSuites();
40 | } catch (err) {
41 | debug('ERROR resetting suites', err);
42 | }
43 | wsEvents.codeceptjs.exit(0);
44 | mocha.suite.suites = [];
45 | });
46 |
47 | debug('codecept.run()');
48 | const done = () => {
49 | event.emit(event.all.result, codecept);
50 | event.emit(event.all.after, codecept);
51 | };
52 |
53 | try {
54 | event.emit(event.all.before, codecept);
55 | global.runner = mocha.run(done);
56 | } catch (e) {
57 | throw new Error(e);
58 | }
59 |
60 | return res.status(200).send('OK');
61 | };
62 |
--------------------------------------------------------------------------------
/lib/utils/port-type-validator.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const portTypeValidator = require('./port-type-validator');
3 |
4 | test('should not throw error for valid "application" type', (t) => {
5 | t.notThrows(() => {
6 | portTypeValidator('application');
7 | });
8 | });
9 |
10 | test('should not throw error for valid "ws" type', (t) => {
11 | t.notThrows(() => {
12 | portTypeValidator('ws');
13 | });
14 | });
15 |
16 | test('should throw error for invalid type', (t) => {
17 | const error = t.throws(() => {
18 | portTypeValidator('invalid');
19 | });
20 | t.is(error.message, 'Type must be "application" or "ws"');
21 | });
22 |
23 | test('should throw error for empty string', (t) => {
24 | const error = t.throws(() => {
25 | portTypeValidator('');
26 | });
27 | t.is(error.message, 'Type must be "application" or "ws"');
28 | });
29 |
30 | test('should throw error for null', (t) => {
31 | const error = t.throws(() => {
32 | portTypeValidator(null);
33 | });
34 | t.is(error.message, 'Type must be "application" or "ws"');
35 | });
36 |
37 | test('should throw error for undefined', (t) => {
38 | const error = t.throws(() => {
39 | portTypeValidator(undefined);
40 | });
41 | t.is(error.message, 'Type must be "application" or "ws"');
42 | });
43 |
44 | test('should throw error for number input', (t) => {
45 | const error = t.throws(() => {
46 | portTypeValidator(123);
47 | });
48 | t.is(error.message, 'Type must be "application" or "ws"');
49 | });
50 |
51 | test('should throw error for case-sensitive mismatch', (t) => {
52 | const error = t.throws(() => {
53 | portTypeValidator('Application');
54 | });
55 | t.is(error.message, 'Type must be "application" or "ws"');
56 | });
57 |
58 | test('should throw error for whitespace variations', (t) => {
59 | const error = t.throws(() => {
60 | portTypeValidator(' application ');
61 | });
62 | t.is(error.message, 'Type must be "application" or "ws"');
63 | });
--------------------------------------------------------------------------------
/src/store/modules/cli.js:
--------------------------------------------------------------------------------
1 | const axios = require('axios');
2 |
3 | const cli = {
4 | namespaced: true,
5 |
6 | state: {
7 | cli: undefined,
8 | prompt: undefined,
9 | commands: undefined,
10 | message: undefined,
11 | actions: {},
12 | steps: [],
13 | },
14 | mutations: {
15 | startCli: (state, data) => {
16 | state.cli = true;
17 | state.prompt = data.prompt;
18 | if (data.commands) {
19 | state.commands = data.commands;
20 | }
21 | },
22 | stopCli: (state) => {
23 | state.cli = undefined;
24 | state.prompt = undefined;
25 | state.commands = undefined;
26 | state.message = undefined;
27 | },
28 | clearCliError: (state) => {
29 | state.message = undefined;
30 | },
31 | setCliError: (state, data) => {
32 | if (!state) return;
33 | state.message = data.message;
34 | },
35 | addStep: (state, step) => {
36 | if (!state.cli) return;
37 | if (step.status !== 'success') return;
38 | state.steps.push(step);
39 | }
40 | },
41 | getters: {
42 | steps: state => state.steps,
43 | show: state => {
44 | return state.cli !== undefined;
45 | },
46 | actions: state => state.actions,
47 | },
48 | actions: {
49 | loadActions: async ({ state }) => {
50 | try {
51 | const resp = await axios.get('/api/actions');
52 | state.actions = resp.data.actions;
53 | } catch (err) {
54 | state.actions = {};
55 | }
56 | },
57 | 'SOCKET_cli.start': function ({ commit }, data) {
58 | commit('startCli', data);
59 | },
60 | 'SOCKET_cli.stop': function ({ commit }, data) {
61 | commit('stopCli', data);
62 | },
63 | 'SOCKET_cli.output': function () {
64 | },
65 | 'SOCKET_cli.error': function ({ commit }, data) {
66 | commit('setCliError', data);
67 | },
68 | 'SOCKET_step.after': function ({ commit }, step) {
69 | commit('addStep', step);
70 | },
71 | }
72 | };
73 |
74 | export default cli;
75 |
--------------------------------------------------------------------------------
/lib/commands/init.js:
--------------------------------------------------------------------------------
1 | const commander = require('commander');
2 | const fs = require('fs');
3 | const path = require('path');
4 |
5 | const codeceptjsFactory = require('../model/codeceptjs-factory');
6 | const { setPort } = require('../config/env');
7 | const portValidator = require('../utils/port-validator');
8 |
9 | module.exports = () => {
10 | const program = new commander.Command();
11 | program.allowUnknownOption();
12 | program.version(JSON.parse(fs.readFileSync(`${__dirname}/../../package.json`, 'utf8')).version);
13 | program
14 | .option('--app', 'launch Electron application')
15 | .option('--port
6 |
11 |
19 |
25 | {{ profile }}
26 |
27 |
28 |
29 |
30 |
31 |
76 |
--------------------------------------------------------------------------------
/lib/model/profile-repository.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const fs = require('fs');
3 | const path = require('path');
4 |
5 | // Since the profile repository is hard to mock due to require() calls,
6 | // let's focus on testing the path construction and basic behavior
7 |
8 | test('should construct correct file path for profile config', (t) => {
9 | const originalCwd = process.cwd;
10 | process.cwd = () => '/test/project';
11 |
12 | try {
13 | // Import after mocking process.cwd
14 | delete require.cache[require.resolve('./profile-repository')];
15 | const profileRepository = require('./profile-repository');
16 |
17 | const originalExistsSync = fs.existsSync;
18 | let checkedPath = '';
19 |
20 | fs.existsSync = (filePath) => {
21 | checkedPath = filePath;
22 | return false;
23 | };
24 |
25 | try {
26 | profileRepository.getProfiles();
27 | const expectedPath = path.join('/test/project', '.codeceptjs', 'profile.conf.js');
28 | t.is(checkedPath, expectedPath);
29 | } finally {
30 | fs.existsSync = originalExistsSync;
31 | }
32 | } finally {
33 | process.cwd = originalCwd;
34 | }
35 | });
36 |
37 | test('getProfiles should return undefined when profile config file does not exist', (t) => {
38 | const originalExistsSync = fs.existsSync;
39 | fs.existsSync = () => false;
40 |
41 | try {
42 | // Clear cache and re-require to get fresh module
43 | delete require.cache[require.resolve('./profile-repository')];
44 | const profileRepository = require('./profile-repository');
45 |
46 | const result = profileRepository.getProfiles();
47 | t.is(result, undefined);
48 | } finally {
49 | fs.existsSync = originalExistsSync;
50 | }
51 | });
52 |
53 | test('getProfile should handle undefined profiles gracefully', (t) => {
54 | const originalExistsSync = fs.existsSync;
55 | fs.existsSync = () => false;
56 |
57 | try {
58 | delete require.cache[require.resolve('./profile-repository')];
59 | const profileRepository = require('./profile-repository');
60 |
61 | const result = profileRepository.getProfile('desktop');
62 | t.is(result, undefined);
63 | } finally {
64 | fs.existsSync = originalExistsSync;
65 | }
66 | });
--------------------------------------------------------------------------------
/test/memory-management.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 |
3 | // Test to verify worker memory management doesn't cause issues
4 | test('worker cleanup functions exist and don\'t throw', (t) => {
5 | // Mock the worker index module
6 | const workerIndex = require('../lib/model/codeceptjs-run-workers/index');
7 |
8 | // Test that the constants are defined correctly
9 | t.true(typeof workerIndex === 'function');
10 |
11 | // This test mainly verifies the module loads without syntax errors
12 | // and that our memory management constants are reasonable
13 | t.pass('Worker module loads without errors');
14 | });
15 |
16 | test('memory management constants are reasonable', (t) => {
17 | // Read the worker file to verify constants exist
18 | const fs = require('fs');
19 | const workerContent = fs.readFileSync('lib/model/codeceptjs-run-workers/index.js', 'utf8');
20 |
21 | // Verify memory management constants are present
22 | t.true(workerContent.includes('MAX_ERRORS'));
23 | t.true(workerContent.includes('MAX_FINISHED_TESTS'));
24 | t.true(workerContent.includes('cleanupWorkerMemory'));
25 |
26 | // Verify limits are reasonable (not too small, not too large)
27 | const maxErrorsMatch = workerContent.match(/MAX_ERRORS\s*=\s*(\d+)/);
28 | const maxTestsMatch = workerContent.match(/MAX_FINISHED_TESTS\s*=\s*(\d+)/);
29 |
30 | if (maxErrorsMatch) {
31 | const maxErrors = parseInt(maxErrorsMatch[1]);
32 | t.true(maxErrors >= 100 && maxErrors <= 10000, 'MAX_ERRORS should be reasonable');
33 | }
34 |
35 | if (maxTestsMatch) {
36 | const maxTests = parseInt(maxTestsMatch[1]);
37 | t.true(maxTests >= 100 && maxTests <= 5000, 'MAX_FINISHED_TESTS should be reasonable');
38 | }
39 | });
40 |
41 | test('file API has memory protections', (t) => {
42 | const fs = require('fs');
43 | const fileApiContent = fs.readFileSync('lib/api/get-file.js', 'utf8');
44 |
45 | // Verify memory protections are present
46 | t.true(fileApiContent.includes('MAX_FILE_SIZE'), 'MAX_FILE_SIZE constant should exist');
47 | t.true(fileApiContent.includes('createReadStream'), 'Should use streaming');
48 | t.true(fileApiContent.includes('stats.size'), 'Should check file size');
49 | t.true(fileApiContent.includes('pipe'), 'Should pipe the stream');
50 | });
--------------------------------------------------------------------------------
/lib/model/snapshot-store/fix-html-snapshot.js:
--------------------------------------------------------------------------------
1 | const { URL } = require('url');
2 | const cheerio = require('cheerio');
3 |
4 | const extractBaseUrl = str => {
5 | const parsed = new URL(str);
6 | return `${parsed.protocol}//${parsed.host}`;
7 | };
8 |
9 | const extractUrlWithPath = str => {
10 | const parsed = new URL(str);
11 | const pathname = parsed.pathname && !parsed.pathname.startsWith('/') ? `/${parsed.pathname}` : parsed.pathname;
12 | return `${parsed.protocol}//${parsed.hostname}${parsed.port ? ':' : ''}${parsed.port ? parsed.port : ''}${pathname}`;
13 | };
14 |
15 | const isDataUrl = linkValue => {
16 | return linkValue.startsWith('data:');
17 | };
18 |
19 | const isSameResource = linkValue => {
20 | return (linkValue[0] !== '/' && !linkValue.startsWith('http'));
21 | };
22 |
23 | const isSameDomain = linkValue => {
24 | return linkValue[0] === '/' && linkValue[1] !== '/';
25 | };
26 |
27 | const isSameProtocol = linkValue => {
28 | return linkValue[0] === '/' && linkValue[1] === '/';
29 | };
30 |
31 | const mapAttr = ($, snapshot, attrName) => {
32 | const parsed = new URL(snapshot.pageUrl);
33 | const protocolHostPort = extractBaseUrl(snapshot.pageUrl);
34 | const protocolHostPortPath = extractUrlWithPath(snapshot.pageUrl);
35 |
36 | return function () {
37 | const linkValue = $(this).attr(attrName);
38 | if (!linkValue) return;
39 |
40 | if (isDataUrl(linkValue)) {
41 | return;
42 | }
43 | if (isSameResource(linkValue)) {
44 | $(this).attr(attrName, `${protocolHostPortPath}/${linkValue}`);
45 | }
46 | if (isSameDomain(linkValue)) {
47 | $(this).attr(attrName, `${protocolHostPort}${linkValue}`);
48 | }
49 | if (isSameProtocol(linkValue)) {
50 | $(this).attr(attrName, `${parsed.protocol}${linkValue}`);
51 | }
52 | };
53 | };
54 |
55 | module.exports = snapshot => {
56 | // disable script tags
57 | snapshot.source = snapshot.source || '';
58 | let $ = cheerio.load(snapshot.source.replace(/
18 |
20 | {{ error.description }}
19 |
21 |
23 | Configure an editor in Settings
22 |24 | To open files you should specify a valid executable for an editor (with arguments). 25 | Learn how to setup popular editors from their docs: 26 |
27 |-
28 |
- 29 | Visual Studio Code → code --goto 33 | 34 |
- 35 | Webstorm → webstorm 39 | 40 |
- 41 | Sublime text → subl 45 | 46 |
48 |
52 | 49 | For other editors set their terminal command. 50 |
51 |
3 |
5 |
6 |
7 |
13 |
14 |
129 |
--------------------------------------------------------------------------------
/lib/api/index.js:
--------------------------------------------------------------------------------
1 | const express = require('express');
2 | const bodyParser = require('body-parser');
3 | const router = express.Router();
4 |
5 | const { getPort } = require('./../config/env');
6 |
7 | const getSnapshotHtml = require('./get-snapshot-html');
8 | const getSnapshotImage = require('./get-snapshot-image');
9 | const listActions = require('./list-actions');
10 | const listScenarios = require('./list-scenarios');
11 | const getScenario = require('./get-scenario');
12 | const getFile = require('./get-file');
13 | const runScenario = require('./run-scenario');
14 | const runNew = require('./new-test');
15 | const stopScenario = require('./stop');
16 | const runScenarioParallel = require('./run-scenario-parallel');
17 | const openTestInEditor = require('./open-test-in-editor');
18 | const saveTestRun = require('./save-testrun');
19 | const getTestRun = require('./get-testrun');
20 | // const listProfiles = require('./list-profiles');
21 | const getSettings = require('./get-settings');
22 | const getConfig = require('./get-config');
23 | const storeSettings = require('./store-settings');
24 | const getScenarioStatus = require('./get-scenario-status');
25 | const getSteps = require('./get-steps');
26 | const getPageObjects = require('./get-page-objects');
27 | const editor = require('./editor');
28 |
29 | const jsonParser = bodyParser.json({ limit: '50mb' });
30 |
31 | router.get('/steps', getSteps);
32 | router.get('/page-objects', getPageObjects);
33 | router.get('/snapshots/html/:id', getSnapshotHtml);
34 | router.get('/snapshots/screenshot/:id', getSnapshotImage);
35 | router.post('/file', jsonParser, getFile);
36 |
37 | router.get('/scenario-status', getScenarioStatus);
38 |
39 | router.get('/scenarios', listScenarios);
40 | router.get('/actions', listActions);
41 | router.get('/scenarios/:id', getScenario);
42 |
43 | router.post('/scenarios/run', jsonParser, runScenario);
44 | router.post('/scenarios/grep/:grep/run', jsonParser, runScenario);
45 | router.post('/scenarios/:id/run', jsonParser, runScenario);
46 | router.post('/scenarios/stop', jsonParser, stopScenario);
47 | router.post('/run-new', jsonParser, runNew);
48 | router.post('/scenarios/:grep/run-parallel', jsonParser, runScenarioParallel);
49 | router.get('/tests/:file/open', openTestInEditor);
50 |
51 | // Code Editor API endpoints
52 | router.get('/editor/scenario/:file/:line', editor.getScenarioSource);
53 | router.put('/editor/scenario/:file/:line', jsonParser, editor.updateScenario);
54 | router.get('/editor/file/:file', editor.getFileContent);
55 | router.put('/editor/file/:file', jsonParser, editor.updateFileContent);
56 | router.get('/editor/autocomplete', editor.getAutocompleteSuggestions);
57 |
58 | router.get('/testruns/:id', getTestRun);
59 | router.put('/testruns/:id', jsonParser, saveTestRun);
60 |
61 | router.get('/config', getConfig);
62 | router.get('/settings', getSettings);
63 | router.put('/settings', jsonParser, storeSettings);
64 | // router.get('/profiles', listProfiles);
65 |
66 | router.get('/ports', (req, res) => {
67 | res.json({
68 | port: getPort('application'),
69 | wsPort: getPort('ws'),
70 | });
71 | });
72 |
73 | module.exports = router;
74 |
--------------------------------------------------------------------------------
/src/components/RunButton.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
7 |
8 |
12 |
14 |
15 |
17 |
18 |
19 |
20 |
21 |
22 |
24 |
25 |
26 |
30 |
51 |
58 |
59 |
60 |
116 |
117 |
123 |
--------------------------------------------------------------------------------
/lib/config/url.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const url = require('./url');
3 |
4 | test('getUrl should return correct URL for application type with default port', (t) => {
5 | // Clear any custom port settings to use defaults
6 | const originalPort = process.env.applicationPort;
7 | delete process.env.applicationPort;
8 |
9 | try {
10 | const result = url.getUrl('application');
11 | // Should use the default (either PORT env var or 3333)
12 | t.true(result.startsWith('http://localhost:'));
13 | t.true(result === 'http://localhost:3333' || result.match(/http:\/\/localhost:\d+/));
14 | } finally {
15 | if (originalPort !== undefined) {
16 | process.env.applicationPort = originalPort;
17 | }
18 | }
19 | });
20 |
21 | test('getUrl should return correct URL for ws type with default port', (t) => {
22 | const originalPort = process.env.wsPort;
23 | delete process.env.wsPort;
24 |
25 | try {
26 | const result = url.getUrl('ws');
27 | t.true(result.startsWith('http://localhost:'));
28 | t.true(result === 'http://localhost:2999' || result.match(/http:\/\/localhost:\d+/));
29 | } finally {
30 | if (originalPort !== undefined) {
31 | process.env.wsPort = originalPort;
32 | }
33 | }
34 | });
35 |
36 | test('getUrl should return correct URL for application type with custom port', (t) => {
37 | // Set the environment variable that the env module actually uses
38 | const originalPort = process.env.applicationPort;
39 | process.env.applicationPort = '8080';
40 |
41 | try {
42 | const result = url.getUrl('application');
43 | t.is(result, 'http://localhost:8080');
44 | } finally {
45 | if (originalPort !== undefined) {
46 | process.env.applicationPort = originalPort;
47 | } else {
48 | delete process.env.applicationPort;
49 | }
50 | }
51 | });
52 |
53 | test('getUrl should return correct URL for ws type with custom port', (t) => {
54 | const originalPort = process.env.wsPort;
55 | process.env.wsPort = '4000';
56 |
57 | try {
58 | const result = url.getUrl('ws');
59 | t.is(result, 'http://localhost:4000');
60 | } finally {
61 | if (originalPort !== undefined) {
62 | process.env.wsPort = originalPort;
63 | } else {
64 | delete process.env.wsPort;
65 | }
66 | }
67 | });
68 |
69 | test('getUrl should validate port type through portTypeValidator', (t) => {
70 | const error = t.throws(() => {
71 | url.getUrl('invalid');
72 | });
73 |
74 | t.is(error.message, 'Type must be "application" or "ws"');
75 | });
76 |
77 | test('getUrl should handle port numbers returned as strings', (t) => {
78 | const originalPort = process.env.applicationPort;
79 | process.env.applicationPort = '9000';
80 |
81 | try {
82 | const result = url.getUrl('application');
83 | t.is(result, 'http://localhost:9000');
84 | } finally {
85 | if (originalPort !== undefined) {
86 | process.env.applicationPort = originalPort;
87 | } else {
88 | delete process.env.applicationPort;
89 | }
90 | }
91 | });
92 |
93 | test('getUrl should handle port number 0', (t) => {
94 | const originalPort = process.env.applicationPort;
95 | process.env.applicationPort = '0';
96 |
97 | try {
98 | const result = url.getUrl('application');
99 | t.is(result, 'http://localhost:0');
100 | } finally {
101 | if (originalPort !== undefined) {
102 | process.env.applicationPort = originalPort;
103 | } else {
104 | delete process.env.applicationPort;
105 | }
106 | }
107 | });
--------------------------------------------------------------------------------
/lib/utils/mkdir.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const fs = require('fs');
3 | const path = require('path');
4 | const mkdir = require('./mkdir');
5 |
6 | // Helper to create unique temp directories for testing
7 | const getTempDir = () => {
8 | return path.join(__dirname, '..', '..', 'test_temp', `test_${Date.now()}_${Math.random().toString(36)}`);
9 | };
10 |
11 | test.afterEach((t) => {
12 | // Clean up any test directories created
13 | if (t.context.testDir && fs.existsSync(t.context.testDir)) {
14 | try {
15 | fs.rmSync(t.context.testDir, { recursive: true, force: true });
16 | } catch (err) {
17 | // Ignore cleanup errors
18 | }
19 | }
20 | });
21 |
22 | test('should create directory that does not exist', (t) => {
23 | const testDir = getTempDir();
24 | t.context.testDir = path.dirname(testDir);
25 |
26 | t.false(fs.existsSync(testDir));
27 |
28 | mkdir(testDir);
29 |
30 | t.true(fs.existsSync(testDir));
31 | t.true(fs.statSync(testDir).isDirectory());
32 | });
33 |
34 | test('should create nested directories recursively', (t) => {
35 | const testDir = path.join(getTempDir(), 'nested', 'deeply', 'nested');
36 | t.context.testDir = path.dirname(path.dirname(path.dirname(testDir)));
37 |
38 | t.false(fs.existsSync(testDir));
39 |
40 | mkdir(testDir);
41 |
42 | t.true(fs.existsSync(testDir));
43 | t.true(fs.statSync(testDir).isDirectory());
44 | });
45 |
46 | test('should not throw error if directory already exists', (t) => {
47 | const testDir = getTempDir();
48 | t.context.testDir = path.dirname(testDir);
49 |
50 | // Create directory first
51 | fs.mkdirSync(testDir, { recursive: true });
52 | t.true(fs.existsSync(testDir));
53 |
54 | // Should not throw when called again
55 | t.notThrows(() => {
56 | mkdir(testDir);
57 | });
58 |
59 | t.true(fs.existsSync(testDir));
60 | });
61 |
62 | test('should handle relative paths', (t) => {
63 | const testBaseDir = getTempDir();
64 | t.context.testDir = path.dirname(testBaseDir);
65 |
66 | // Create base directory
67 | fs.mkdirSync(testBaseDir, { recursive: true });
68 |
69 | const relativeDir = path.join(testBaseDir, 'relative', 'test', 'dir');
70 |
71 | t.false(fs.existsSync(relativeDir));
72 |
73 | mkdir(relativeDir);
74 |
75 | t.true(fs.existsSync(relativeDir));
76 | t.true(fs.statSync(relativeDir).isDirectory());
77 | });
78 |
79 | test('should rethrow non-EEXIST errors', (t) => {
80 | // Try to create directory in a location that should fail (like in /etc on Unix)
81 | // This test may be platform dependent, so we'll simulate the behavior
82 |
83 | // Mock fs.existsSync to return false and fs.mkdirSync to throw a non-EEXIST error
84 | const originalExistsSync = fs.existsSync;
85 | const originalMkdirSync = fs.mkdirSync;
86 |
87 | fs.existsSync = () => false;
88 | fs.mkdirSync = () => {
89 | const error = new Error('Permission denied');
90 | error.code = 'EACCES';
91 | throw error;
92 | };
93 |
94 | try {
95 | const error = t.throws(() => {
96 | mkdir('/invalid/permission/test');
97 | });
98 | t.is(error.code, 'EACCES');
99 | t.is(error.message, 'Permission denied');
100 | } finally {
101 | // Restore original functions
102 | fs.existsSync = originalExistsSync;
103 | fs.mkdirSync = originalMkdirSync;
104 | }
105 | });
106 |
107 | test('should handle empty string by throwing error', (t) => {
108 | // Empty string should throw an error as it's not a valid directory path
109 | const error = t.throws(() => {
110 | mkdir('');
111 | });
112 | t.is(error.code, 'ENOENT');
113 | });
--------------------------------------------------------------------------------
/src/background.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | import path from 'path';
4 | import { BrowserWindow, app, protocol, screen } from 'electron';
5 | import {
6 | createProtocol,
7 | /* installVueDevtools */
8 | } from 'vue-cli-plugin-electron-builder/lib';
9 | const isDevelopment = process.env.NODE_ENV !== 'production';
10 |
11 | // Keep a global reference of the window object, if you don't, the window will
12 | // be closed automatically when the JavaScript object is garbage collected.
13 | let win;
14 |
15 | // Scheme must be registered before the app is ready
16 | protocol.registerSchemesAsPrivileged([{ scheme: 'app', privileges: { secure: true, standard: true } }]);
17 |
18 |
19 | function createWindow () {
20 | const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().size;
21 |
22 | const width = Math.floor(screenWidth / 3.5) || 500;
23 | // Create the browser window.
24 | win = new BrowserWindow({
25 | width,
26 | height: screenHeight-50,
27 | minWidth: 500,
28 | x: screenWidth,
29 | y: 0,
30 | autoHideMenuBar: true,
31 | icon: path.join(__dirname, 'public/icon.png'),
32 | webPreferences: {
33 | nodeIntegration: true,
34 | nodeIntegrationInWorker: true,
35 | },
36 | });
37 |
38 | if (process.env.WEBPACK_DEV_SERVER_URL) {
39 | // Load the url of the dev server if in development mode
40 | win.loadURL(process.env.WEBPACK_DEV_SERVER_URL);
41 | // To open Dev Tools by default uncomment next line
42 | // if (!process.env.IS_TEST) win.webContents.openDevTools();
43 | } else {
44 | createProtocol('app');
45 | // Load the index.html when not in development
46 | win.loadURL('app://./index.html');
47 | }
48 |
49 | win.on('closed', () => {
50 | win = null;
51 | });
52 | }
53 |
54 | // Quit when all windows are closed.
55 | app.on('window-all-closed', () => {
56 | // On macOS it is common for applications and their menu bar
57 | // to stay active until the user quits explicitly with Cmd + Q
58 | if (process.platform !== 'darwin') {
59 | app.quit();
60 | }
61 | });
62 |
63 | app.on('activate', () => {
64 | // On macOS it's common to re-create a window in the app when the
65 | // dock icon is clicked and there are no other windows open.
66 | if (win === null) {
67 | createWindow();
68 | }
69 | });
70 |
71 | // This method will be called when Electron has finished
72 | // initialization and is ready to create browser windows.
73 | // Some APIs can only be used after this event occurs.
74 | app.on('ready', async () => {
75 | if (isDevelopment && !process.env.IS_TEST) {
76 | // Install Vue Devtools
77 | // Devtools extensions are broken in Electron 6.0.0 and greater
78 | // See https://github.com/nklayman/vue-cli-plugin-electron-builder/issues/378 for more info
79 | // Electron will not launch with Devtools extensions installed on Windows 10 with dark mode
80 | // If you are not using Windows 10 dark mode, you may uncomment these lines
81 | // In addition, if the linked issue is closed, you can upgrade electron and uncomment these lines
82 | // try {
83 | // await installVueDevtools()
84 | // } catch (e) {
85 | // console.error('Vue Devtools failed to install:', e.toString())
86 | // }
87 |
88 | }
89 | createWindow();
90 | });
91 |
92 | // Exit cleanly on request from parent process in development mode.
93 | if (isDevelopment) {
94 | if (process.platform === 'win32') {
95 | process.on('message', data => {
96 | if (data === 'graceful-exit') {
97 | app.quit();
98 | }
99 | });
100 | } else {
101 | process.on('SIGTERM', () => {
102 | app.quit();
103 | });
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/src/components/Logo.vue:
--------------------------------------------------------------------------------
1 |
2 |
55 |
57 |
9 | 
13 |
14 |
17 |
18 |
19 |
71 |
13 |
14 |
17 |
3 |
8 | {{ feature.fileBaseName }}
9 |
10 |
11 |
12 |
13 | {{ feature.feature.title }}
14 |
15 |
33 |
51 |
52 |
53 |
108 |
109 |
154 |
--------------------------------------------------------------------------------
/lib/api/stop.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 |
3 | // Mock the dependencies that can cause hanging processes
4 | const mockEvent = {
5 | dispatcher: {
6 | once: () => {}, // No-op to prevent hanging
7 | removeAllListeners: () => {}
8 | },
9 | all: {
10 | result: 'test.result'
11 | }
12 | };
13 |
14 | const mockWsEvents = {
15 | codeceptjs: {
16 | exit: () => {} // No-op to prevent socket connections
17 | }
18 | };
19 |
20 | // Mock the modules before requiring stop.js
21 | const Module = require('module');
22 | const originalRequire = Module.prototype.require;
23 |
24 | Module.prototype.require = function(id) {
25 | if (id === 'codeceptjs') {
26 | return { event: mockEvent };
27 | }
28 | if (id === '../model/ws-events') {
29 | return mockWsEvents;
30 | }
31 | return originalRequire.apply(this, arguments);
32 | };
33 |
34 | const stop = require('./stop');
35 |
36 | // Restore original require after loading
37 | Module.prototype.require = originalRequire;
38 |
39 | test('should return OK status when no global runner exists', async (t) => {
40 | // Add timeout to prevent hanging
41 | const timeout = setTimeout(() => {
42 | t.fail('Test timed out');
43 | }, 2000);
44 |
45 | const originalRunner = global.runner;
46 | global.runner = undefined;
47 |
48 | let statusCode;
49 | let responseData;
50 |
51 | const req = {};
52 | const res = {
53 | status: (code) => {
54 | statusCode = code;
55 | return {
56 | send: (data) => {
57 | responseData = data;
58 | return res;
59 | }
60 | };
61 | }
62 | };
63 |
64 | try {
65 | await stop(req, res);
66 |
67 | t.is(statusCode, 200);
68 | t.is(responseData, 'OK');
69 | clearTimeout(timeout);
70 | } finally {
71 | global.runner = originalRunner;
72 | clearTimeout(timeout);
73 | }
74 | });
75 |
76 | test('should call abort on global runner when it exists', async (t) => {
77 | // Add timeout to prevent hanging
78 | const timeout = setTimeout(() => {
79 | t.fail('Test timed out');
80 | }, 2000);
81 |
82 | const originalRunner = global.runner;
83 | let abortCalled = false;
84 |
85 | global.runner = {
86 | abort: () => {
87 | abortCalled = true;
88 | },
89 | _abort: true
90 | };
91 |
92 | let statusCode;
93 | let responseData;
94 |
95 | const req = {};
96 | const res = {
97 | status: (code) => {
98 | statusCode = code;
99 | return {
100 | send: (data) => {
101 | responseData = data;
102 | return res;
103 | }
104 | };
105 | }
106 | };
107 |
108 | try {
109 | await stop(req, res);
110 |
111 | t.true(abortCalled);
112 | t.is(statusCode, 200);
113 | t.is(responseData, 'OK');
114 | clearTimeout(timeout);
115 | } finally {
116 | global.runner = originalRunner;
117 | clearTimeout(timeout);
118 | }
119 | });
120 |
121 | test('should handle null global runner gracefully', async (t) => {
122 | // Add timeout to prevent hanging
123 | const timeout = setTimeout(() => {
124 | t.fail('Test timed out');
125 | }, 2000);
126 |
127 | const originalRunner = global.runner;
128 | global.runner = null;
129 |
130 | let statusCode;
131 | let responseData;
132 |
133 | const req = {};
134 | const res = {
135 | status: (code) => {
136 | statusCode = code;
137 | return {
138 | send: (data) => {
139 | responseData = data;
140 | return res;
141 | }
142 | };
143 | }
144 | };
145 |
146 | try {
147 | await stop(req, res);
148 |
149 | t.is(statusCode, 200);
150 | t.is(responseData, 'OK');
151 | clearTimeout(timeout);
152 | } finally {
153 | global.runner = originalRunner;
154 | clearTimeout(timeout);
155 | }
156 | });
--------------------------------------------------------------------------------
/src/components/Console.vue:
--------------------------------------------------------------------------------
1 |
2 |
11 |
12 |
13 | {{ feature.feature.title }}
14 |
15 |
21 | {{ tag }}
22 |
23 |
24 |
25 |
29 | Run
30 |
31 |
32 |
33 | -
34 |
-
39 |
43 |
44 |
14 |
29 |
15 |
19 |
20 |
24 | {{ step.logs.length }}
25 |
26 |
27 |
28 | -
38 |
- 43 | 44 | 45 | {{ itemLog.message }} 46 | @ 47 | {{ itemLog.url }} 48 | 49 | {{ duration(itemLog) }} 50 | 51 |
3 |
7 |
11 |
15 |
19 |
23 |
24 |
28 |
29 |
30 |
31 | {{ scenario.title }}
32 |
33 |
34 |
40 | {{ tag }}
41 |
42 |
46 | {{ testDuration(scenario.id) }}s
47 |
48 |
52 | ·
53 | {{ humanize(testStartedAt(scenario.id)) }}
54 |
55 |
59 | ·
60 | {{ testErrorMessage(scenario.id) }}
61 |
62 |
63 |
64 |
65 |
138 |
156 |
--------------------------------------------------------------------------------
/test/ui-enhancements.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const fs = require('fs');
3 | const path = require('path');
4 |
5 | test('Enhanced UI components exist and have proper structure', (t) => {
6 | const enhancedLoadingPath = path.join(__dirname, '..', 'src', 'components', 'EnhancedLoading.vue');
7 | const toastNotificationPath = path.join(__dirname, '..', 'src', 'components', 'ToastNotification.vue');
8 |
9 | // Check that enhanced loading component exists
10 | t.true(fs.existsSync(enhancedLoadingPath), 'EnhancedLoading component should exist');
11 |
12 | // Check that toast notification component exists
13 | t.true(fs.existsSync(toastNotificationPath), 'ToastNotification component should exist');
14 |
15 | const loadingContent = fs.readFileSync(enhancedLoadingPath, 'utf8');
16 | const toastContent = fs.readFileSync(toastNotificationPath, 'utf8');
17 |
18 | // Check enhanced loading features
19 | t.true(loadingContent.includes('progress-indicator'), 'Loading should support progress indication');
20 | t.true(loadingContent.includes('cancellable'), 'Loading should support cancellation');
21 | t.true(loadingContent.includes('backdrop-filter'), 'Loading should have modern backdrop blur');
22 |
23 | // Check toast notification features
24 | t.true(toastContent.includes('toast-success'), 'Toast should support success type');
25 | t.true(toastContent.includes('toast-error'), 'Toast should support error type');
26 | t.true(toastContent.includes('dismissible'), 'Toast should be dismissible');
27 | t.true(toastContent.includes('transition-group'), 'Toast should have smooth animations');
28 | });
29 |
30 | test('TestStatistics component has enhanced visual feedback', (t) => {
31 | const testStatsPath = path.join(__dirname, '..', 'src', 'components', 'TestStatistics.vue');
32 | const content = fs.readFileSync(testStatsPath, 'utf8');
33 |
34 | // Check for progress bars
35 | t.true(content.includes('progress-bar'), 'Should have progress bars for test results');
36 | t.true(content.includes('successPercentage'), 'Should calculate success percentage');
37 | t.true(content.includes('failedPercentage'), 'Should calculate failed percentage');
38 |
39 | // Check for badge styling
40 | t.true(content.includes('success-badge'), 'Should have styled success badges');
41 | t.true(content.includes('error-badge'), 'Should have styled error badges');
42 | t.true(content.includes('total-badge'), 'Should have styled total count badge');
43 |
44 | // Check for enhanced running state
45 | t.true(content.includes('running-indicator'), 'Should have running indicator');
46 | t.true(content.includes('pulse-button'), 'Should have pulsing pause button');
47 | });
48 |
49 | test('Step component has enhanced visual indicators', (t) => {
50 | const stepPath = path.join(__dirname, '..', 'src', 'components', 'Step.vue');
51 | const content = fs.readFileSync(stepPath, 'utf8');
52 |
53 | // Check for status icons
54 | t.true(content.includes('stepStatusIcon'), 'Should have step status icons');
55 | t.true(content.includes('step-passed'), 'Should have passed step styling');
56 | t.true(content.includes('step-failed'), 'Should have failed step styling');
57 |
58 | // Check for duration badges
59 | t.true(content.includes('duration-badge'), 'Should have duration badges');
60 | t.true(content.includes('duration-fast'), 'Should classify fast steps');
61 | t.true(content.includes('duration-slow'), 'Should classify slow steps');
62 |
63 | // Check for console badges
64 | t.true(content.includes('console-badge'), 'Should have console log badges');
65 | });
66 |
67 | test('IDE-like split view is implemented in ScenariosPage', (t) => {
68 | const scenariosPagePath = path.join(__dirname, '..', 'src', 'components', 'pages', 'ScenariosPage.vue');
69 | const content = fs.readFileSync(scenariosPagePath, 'utf8');
70 |
71 | // Check for IDE layout structure
72 | t.true(content.includes('ide-layout'), 'Should have IDE layout container');
73 | t.true(content.includes('test-list-panel'), 'Should have test list panel');
74 | t.true(content.includes('test-preview-panel'), 'Should have test preview panel');
75 |
76 | // Check for responsive behavior
77 | t.true(content.includes('with-preview'), 'Should have conditional preview state');
78 | t.true(content.includes('window.innerWidth >= 1024'), 'Should be responsive to screen size');
79 |
80 | // Check for code display
81 | t.true(content.includes('test-code'), 'Should display test code');
82 | t.true(content.includes('loadTestCode'), 'Should load test code dynamically');
83 | });
--------------------------------------------------------------------------------
/lib/utils/absolutize-paths.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 | const path = require('path');
3 | const absolutizePaths = require('./absolutize-paths');
4 |
5 | test.beforeEach((t) => {
6 | // Store original global.codecept_dir
7 | t.context.originalCodeceptDir = global.codecept_dir;
8 | });
9 |
10 | test.afterEach((t) => {
11 | // Restore original global.codecept_dir
12 | global.codecept_dir = t.context.originalCodeceptDir;
13 | });
14 |
15 | test('should convert relative paths to absolute paths', (t) => {
16 | global.codecept_dir = '/test/project';
17 |
18 | const input = {
19 | configFile: 'codecept.conf.js',
20 | outputDir: 'output',
21 | testsDir: './features'
22 | };
23 |
24 | const result = absolutizePaths(input);
25 |
26 | t.is(result.configFile, path.resolve('/test/project', 'codecept.conf.js'));
27 | t.is(result.outputDir, path.resolve('/test/project', 'output'));
28 | t.is(result.testsDir, path.resolve('/test/project', './features'));
29 | });
30 |
31 | test('should leave absolute paths unchanged', (t) => {
32 | global.codecept_dir = '/test/project';
33 |
34 | const input = {
35 | configFile: '/absolute/path/codecept.conf.js',
36 | outputDir: '/absolute/output',
37 | testsDir: '/absolute/features'
38 | };
39 |
40 | const result = absolutizePaths(input);
41 |
42 | t.is(result.configFile, '/absolute/path/codecept.conf.js');
43 | t.is(result.outputDir, '/absolute/output');
44 | t.is(result.testsDir, '/absolute/features');
45 | });
46 |
47 | test('should handle mixed absolute and relative paths', (t) => {
48 | global.codecept_dir = '/test/project';
49 |
50 | const input = {
51 | configFile: '/absolute/codecept.conf.js',
52 | outputDir: 'relative/output',
53 | testsDir: '/absolute/features'
54 | };
55 |
56 | const result = absolutizePaths(input);
57 |
58 | t.is(result.configFile, '/absolute/codecept.conf.js');
59 | t.is(result.outputDir, path.resolve('/test/project', 'relative/output'));
60 | t.is(result.testsDir, '/absolute/features');
61 | });
62 |
63 | test('should handle empty strings by leaving them unchanged', (t) => {
64 | global.codecept_dir = '/test/project';
65 |
66 | const input = {
67 | configFile: '',
68 | outputDir: 'output'
69 | };
70 |
71 | const result = absolutizePaths(input);
72 |
73 | t.is(result.configFile, '');
74 | t.is(result.outputDir, path.resolve('/test/project', 'output'));
75 | });
76 |
77 | test('should handle null values by leaving them unchanged', (t) => {
78 | global.codecept_dir = '/test/project';
79 |
80 | const input = {
81 | configFile: null,
82 | outputDir: 'output',
83 | testsDir: undefined
84 | };
85 |
86 | const result = absolutizePaths(input);
87 |
88 | t.is(result.configFile, null);
89 | t.is(result.outputDir, path.resolve('/test/project', 'output'));
90 | t.is(result.testsDir, undefined);
91 | });
92 |
93 | test('should handle non-string values by leaving them unchanged', (t) => {
94 | global.codecept_dir = '/test/project';
95 |
96 | const input = {
97 | port: 8080,
98 | enabled: true,
99 | paths: ['test1', 'test2'],
100 | configFile: 'codecept.conf.js'
101 | };
102 |
103 | const result = absolutizePaths(input);
104 |
105 | t.is(result.port, 8080);
106 | t.is(result.enabled, true);
107 | t.deepEqual(result.paths, ['test1', 'test2']);
108 | t.is(result.configFile, path.resolve('/test/project', 'codecept.conf.js'));
109 | });
110 |
111 | test('should work when global.codecept_dir is not set', (t) => {
112 | global.codecept_dir = undefined;
113 |
114 | const input = {
115 | configFile: 'codecept.conf.js',
116 | outputDir: './output'
117 | };
118 |
119 | const result = absolutizePaths(input);
120 |
121 | t.is(result.configFile, path.resolve('', 'codecept.conf.js'));
122 | t.is(result.outputDir, path.resolve('', './output'));
123 | });
124 |
125 | test('should return the same object (mutating original)', (t) => {
126 | global.codecept_dir = '/test/project';
127 |
128 | const input = {
129 | configFile: 'codecept.conf.js'
130 | };
131 |
132 | const result = absolutizePaths(input);
133 |
134 | t.is(result, input); // Same object reference
135 | t.is(input.configFile, path.resolve('/test/project', 'codecept.conf.js'));
136 | });
137 |
138 | test('should handle empty object', (t) => {
139 | const input = {};
140 | const result = absolutizePaths(input);
141 |
142 | t.deepEqual(result, {});
143 | t.is(result, input);
144 | });
--------------------------------------------------------------------------------
/test/language-detection.spec.js:
--------------------------------------------------------------------------------
1 | const test = require('ava');
2 |
3 | // Use dynamic import for ES modules
4 | let detectLanguage, getLanguageDisplayName;
5 |
6 | test.before(async () => {
7 | const module = await import('../src/utils/languageDetection.js');
8 | detectLanguage = module.detectLanguage;
9 | getLanguageDisplayName = module.getLanguageDisplayName;
10 | });
11 |
12 | test('detectLanguage › should detect JavaScript files correctly', t => {
13 | const result = detectLanguage('test.js');
14 | t.is(result.monaco, 'javascript');
15 | t.is(result.highlightjs, 'javascript');
16 | });
17 |
18 | test('detectLanguage › should detect TypeScript files correctly', t => {
19 | const result = detectLanguage('component.ts');
20 | t.is(result.monaco, 'typescript');
21 | t.is(result.highlightjs, 'typescript');
22 | });
23 |
24 | test('detectLanguage › should detect JSON files correctly', t => {
25 | const result = detectLanguage('package.json');
26 | t.is(result.monaco, 'json');
27 | t.is(result.highlightjs, 'json');
28 | });
29 |
30 | test('detectLanguage › should detect feature files correctly', t => {
31 | const result = detectLanguage('login.feature');
32 | t.is(result.monaco, 'gherkin');
33 | t.is(result.highlightjs, 'gherkin');
34 | });
35 |
36 | test('detectLanguage › should detect YAML files correctly', t => {
37 | const result = detectLanguage('config.yaml');
38 | t.is(result.monaco, 'yaml');
39 | t.is(result.highlightjs, 'yaml');
40 |
41 | const result2 = detectLanguage('config.yml');
42 | t.is(result2.monaco, 'yaml');
43 | t.is(result2.highlightjs, 'yaml');
44 | });
45 |
46 | test('detectLanguage › should detect CSS files correctly', t => {
47 | const result = detectLanguage('styles.css');
48 | t.is(result.monaco, 'css');
49 | t.is(result.highlightjs, 'css');
50 | });
51 |
52 | test('detectLanguage › should detect HTML files correctly', t => {
53 | const result = detectLanguage('index.html');
54 | t.is(result.monaco, 'html');
55 | t.is(result.highlightjs, 'html');
56 | });
57 |
58 | test('detectLanguage › should detect Markdown files correctly', t => {
59 | const result = detectLanguage('README.md');
60 | t.is(result.monaco, 'markdown');
61 | t.is(result.highlightjs, 'markdown');
62 | });
63 |
64 | test('detectLanguage › should handle files without extensions by defaulting to JavaScript', t => {
65 | const result = detectLanguage('Dockerfile');
66 | t.is(result.monaco, 'javascript');
67 | t.is(result.highlightjs, 'javascript');
68 | });
69 |
70 | test('detectLanguage › should handle unknown extensions by defaulting to JavaScript', t => {
71 | const result = detectLanguage('file.unknown');
72 | t.is(result.monaco, 'javascript');
73 | t.is(result.highlightjs, 'javascript');
74 | });
75 |
76 | test('detectLanguage › should handle null/undefined input by defaulting to JavaScript', t => {
77 | const result1 = detectLanguage(null);
78 | t.is(result1.monaco, 'javascript');
79 | t.is(result1.highlightjs, 'javascript');
80 |
81 | const result2 = detectLanguage(undefined);
82 | t.is(result2.monaco, 'javascript');
83 | t.is(result2.highlightjs, 'javascript');
84 |
85 | const result3 = detectLanguage('');
86 | t.is(result3.monaco, 'javascript');
87 | t.is(result3.highlightjs, 'javascript');
88 | });
89 |
90 | test('detectLanguage › should handle full file paths correctly', t => {
91 | const result = detectLanguage('/path/to/my/test.feature');
92 | t.is(result.monaco, 'gherkin');
93 | t.is(result.highlightjs, 'gherkin');
94 | });
95 |
96 | test('getLanguageDisplayName › should return correct display names', t => {
97 | t.is(getLanguageDisplayName('test.js'), 'JavaScript');
98 | t.is(getLanguageDisplayName('component.ts'), 'TypeScript');
99 | t.is(getLanguageDisplayName('package.json'), 'JSON');
100 | t.is(getLanguageDisplayName('login.feature'), 'Gherkin (BDD)');
101 | t.is(getLanguageDisplayName('config.yaml'), 'YAML');
102 | t.is(getLanguageDisplayName('styles.css'), 'CSS');
103 | t.is(getLanguageDisplayName('index.html'), 'HTML');
104 | t.is(getLanguageDisplayName('README.md'), 'Markdown');
105 | t.is(getLanguageDisplayName('unknown.ext'), 'JavaScript');
106 | });
107 |
108 | test('detectLanguage › should be case-insensitive for extensions', t => {
109 | const result1 = detectLanguage('TEST.JS');
110 | t.is(result1.monaco, 'javascript');
111 |
112 | const result2 = detectLanguage('Component.TS');
113 | t.is(result2.monaco, 'typescript');
114 |
115 | const result3 = detectLanguage('Config.YAML');
116 | t.is(result3.monaco, 'yaml');
117 | });
--------------------------------------------------------------------------------
/src/components/EnhancedLoading.vue:
--------------------------------------------------------------------------------
1 |
2 |
42 |
43 |
44 |
75 |
76 |
--------------------------------------------------------------------------------
/lib/model/ws-events.js:
--------------------------------------------------------------------------------
1 | const { getUrl } = require('../config/url');
2 | const safeSerialize = require('../utils/safe-serialize');
3 |
4 | // Only create socket connection when not in test environment
5 | let socket;
6 |
7 | if (process.env.NODE_ENV !== 'test' && !process.env.AVA_WORKER_ID) {
8 | const WS_URL = getUrl('ws');
9 | socket = require('socket.io-client')(WS_URL, {
10 | timeout: 5000,
11 | forceNew: true
12 | });
13 |
14 | // Ensure socket closes when process exits to prevent hanging
15 | process.on('exit', () => {
16 | if (socket && socket.connected) {
17 | socket.disconnect();
18 | }
19 | });
20 |
21 | process.on('SIGINT', () => {
22 | if (socket && socket.connected) {
23 | socket.disconnect();
24 | }
25 | process.exit(0);
26 | });
27 | } else {
28 | // Mock socket for tests
29 | socket = {
30 | emit: () => {},
31 | connected: false,
32 | disconnect: () => {}
33 | };
34 | }
35 |
36 | module.exports = {
37 | events: [
38 | 'console.error',
39 | 'console.log',
40 | 'network.failed_request',
41 | 'codeceptjs:scenarios.updated',
42 | 'codeceptjs:scenarios.parseerror',
43 | 'codeceptjs:config.updated',
44 | 'codeceptjs:file.changed',
45 | 'codeceptjs.started',
46 | 'codeceptjs.exit',
47 | 'metastep.changed',
48 | 'cli.start',
49 | 'cli.stop',
50 | 'cli.error',
51 | 'cli.output',
52 | 'cli.line',
53 | 'cli.close',
54 | 'suite.before',
55 | 'test.before',
56 | 'test.after',
57 | 'test.failed',
58 | 'test.passed',
59 | 'step.before',
60 | 'step.after',
61 | 'step.comment',
62 | 'step.passed',
63 | 'finish',
64 | ],
65 | console: {
66 | jsError(err) {
67 | socket.emit('console.error', safeSerialize({
68 | type: 'js',
69 | error: err,
70 | }));
71 | },
72 | error(err) {
73 | socket.emit('console.error', safeSerialize({
74 | type: 'error',
75 | error: err,
76 | }));
77 | },
78 | log(type, url, lineno, args) {
79 | socket.emit('console.log', safeSerialize({
80 | type,
81 | url,
82 | lineno,
83 | args
84 | }));
85 | }
86 | },
87 | network: {
88 | failedRequest(data) {
89 | socket.emit('network.failed_request', safeSerialize(data));
90 | }
91 | },
92 | rtr: {
93 | suiteBefore(data) {
94 | socket.emit('suite.before', safeSerialize(data));
95 | },
96 | testBefore(data) {
97 | socket.emit('test.before', safeSerialize(data));
98 | },
99 | testAfter(data) {
100 | socket.emit('test.after', safeSerialize(data));
101 | },
102 | stepBefore(data) {
103 | socket.emit('step.before', safeSerialize(data));
104 | },
105 | stepAfter(data) {
106 | socket.emit('step.after', safeSerialize(data));
107 | },
108 | stepComment(comment) {
109 | socket.emit('step.comment', safeSerialize(comment));
110 | },
111 | stepPassed(data) {
112 | socket.emit('step.passed', safeSerialize(data));
113 | },
114 | metaStepChanged(data) {
115 | socket.emit('metastep.changed', safeSerialize(data));
116 | },
117 | testPassed(data) {
118 | socket.emit('test.passed', safeSerialize(data));
119 | },
120 | testFailed(data) {
121 | socket.emit('test.failed', safeSerialize(data));
122 | },
123 | testRunFinished() {
124 | socket.emit('testrun.finish');
125 | }
126 | },
127 | codeceptjs: {
128 | scenariosUpdated() {
129 | // just notify the frontend that scenarios have been changed
130 | // it's the frontends responsibilty to actually get
131 | // the updated list of scenarios
132 | socket.emit('codeceptjs:scenarios.updated');
133 | },
134 | scenariosParseError(err) {
135 | socket.emit('codeceptjs:scenarios.parseerror', safeSerialize({
136 | message: err.message,
137 | stack: err.stack,
138 | }));
139 | },
140 | configUpdated(configFile) {
141 | socket.emit('codeceptjs:config.updated', safeSerialize({
142 | file: configFile,
143 | timestamp: new Date().toISOString()
144 | }));
145 | },
146 | fileChanged(filePath, changeType) {
147 | socket.emit('codeceptjs:file.changed', safeSerialize({
148 | file: filePath,
149 | changeType: changeType, // 'add', 'change', 'unlink'
150 | timestamp: new Date().toISOString()
151 | }));
152 | },
153 | started(data) {
154 | socket.emit('codeceptjs.started', safeSerialize(data));
155 | },
156 | exit(data) {
157 | socket.emit('codeceptjs.exit', safeSerialize(data));
158 | },
159 | error(err) {
160 | socket.emit('codeceptjs.error', safeSerialize(err));
161 | }
162 | }
163 | };
164 |
--------------------------------------------------------------------------------