@govtechsg/oobee 0.10.20

package/__mocks__/mockFunctions.ts

@@ -0,0 +1,32 @@
+/* eslint-disable no-undef */
+const actualFs = jest.requireActual('fs-extra');
+const actualPath = jest.requireActual('path');
+
+export const createIssueCountMap = jest.fn((critical, serious, moderate, minor) => {
+  const totalCount = critical + serious + moderate + minor;
+  return [
+    `Total Issue Count: ${totalCount}`,
+    `Issue Breakdown`,
+    `Critical: ${critical}`,
+    `Serious: ${serious}`,
+    `Moderate: ${moderate}`,
+    `Minor: ${minor}`,
+  ];
+});
+
+export const createAlertMessage = jest.fn(warnlevel => [
+  [
+    `Issues with impact level - ${warnlevel} found in your project. Please review the accessibility issues.`,
+  ],
+  { border: true, borderColor: 'red' },
+]);
+
+export const createFinalResultsInJson = jest.fn((allissues, dateTimeStamp) => {
+  const finalResultsInJson = JSON.stringify(
+    { startTime: dateTimeStamp, count: allissues.length, allissues },
+    null,
+    4,
+  );
+
+  return finalResultsInJson;
+});

package/__mocks__/mockIssues.ts

@@ -0,0 +1,64 @@
+// Issues with all warn level except none
+// 0: critical, 1: serious, 2: moderate, 3: minor
+export const allIssues = [
+  {
+    url: 'https://www.isomer.gov.sg/terms-of-use/',
+    page: '/terms-of-use/',
+    description: 'Buttons must have discernible text',
+    helpUrl: 'https://dequeuniversity.com/rules/axe/4.2/button-name?application=oobee',
+    htmlElement:
+      "<button class='bp-button'><i class='sgds-icon sgds-icon-mail is-size-4'></i>/button>",
+    order: 3,
+    wcagLinks: [['https://www.w3.org/WAI/WCAG21/Understanding/text-alternatives']],
+    impact: 'critical',
+    disabilities: ['disabilities'],
+  },
+  {
+    url: 'https://www.isomer.gov.sg/terms-of-use/',
+    page: '/terms-of-use/',
+    description: 'Buttons must have discernible text',
+    helpUrl: 'https://dequeuniversity.com/rules/axe/4.2/button-name?application=oobee',
+    htmlElement:
+      "<button class='bp-button'><i class='sgds-icon sgds-icon-mail is-size-4'></i>/button>",
+    order: 3,
+    wcagLinks: [['https://www.w3.org/WAI/WCAG21/Understanding/text-alternatives']],
+    impact: 'serious',
+    disabilities: ['disabilities'],
+  },
+  {
+    url: 'https://www.isomer.gov.sg/terms-of-use/',
+    page: '/terms-of-use/',
+    description: 'Buttons must have discernible text',
+    helpUrl: 'https://dequeuniversity.com/rules/axe/4.2/button-name?application=oobee',
+    htmlElement:
+      "<button class='bp-button'><i class='sgds-icon sgds-icon-mail is-size-4'></i>/button>",
+    order: 3,
+    wcagLinks: [['https://www.w3.org/WAI/WCAG21/Understanding/text-alternatives']],
+    impact: 'moderate',
+    disabilities: ['disabilities'],
+  },
+  {
+    url: 'https://www.isomer.gov.sg/terms-of-use/',
+    page: '/terms-of-use/',
+    description: 'Buttons must have discernible text',
+    helpUrl: 'https://dequeuniversity.com/rules/axe/4.2/button-name?application=oobee',
+    htmlElement:
+      "<button class='bp-button'><i class='sgds-icon sgds-icon-mail is-size-4'></i>/button>",
+    order: 3,
+    wcagLinks: [['https://www.w3.org/WAI/WCAG21/Understanding/text-alternatives']],
+    impact: 'minor',
+    disabilities: ['disabilities'],
+  },
+];
+
+// All Except Target Warn Level Issues
+export const allExceptCritical = [allIssues[1], allIssues[2], allIssues[3]];
+export const allExceptSerious = [allIssues[0], allIssues[2], allIssues[3]];
+export const allExceptModerate = [allIssues[0], allIssues[1], allIssues[3]];
+export const allExceptMinor = [allIssues[0], allIssues[1], allIssues[2]];
+
+// Individual Target Warn Level Issues
+export const criticalOnly = [allIssues[0]];
+export const seriousOnly = [allIssues[1]];
+export const moderateOnly = [allIssues[2]];
+export const minorOnly = [allIssues[3]];

package/__mocks__/mock_all_issues/000000001.json

@@ -0,0 +1,64 @@
+{
+  "url": "https://www.sitemaps.org/",
+  "page": "/",
+  "errors": [
+    {
+      "id": "color-contrast",
+      "description": "Elements must have sufficient color contrast",
+      "impact": "serious",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/color-contrast?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<p class=\"date\">\n\n                Last Updated: 17 April 2020\n\n            </p>"
+        }
+      ]
+    },
+    {
+      "id": "html-has-lang",
+      "description": "<html> element must have a lang attribute",
+      "impact": "serious",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/html-has-lang?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\">"
+        }
+      ]
+    },
+    {
+      "id": "landmark-one-main",
+      "description": "Document should have one main landmark",
+      "impact": "moderate",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/landmark-one-main?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\">"
+        }
+      ]
+    },
+    {
+      "id": "region",
+      "description": "All page content should be contained by landmarks",
+      "impact": "moderate",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/region?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<div id=\"container\">"
+        },
+        {
+          "htmlElement": "<div id=\"footer\">\n\n        <p>\n\n            <a href=\"terms.php\">Terms and conditions</a></p>\n\n    </div>"
+        }
+      ]
+    },
+    {
+      "id": "select-name",
+      "description": "Select element must have an accessible name",
+      "impact": "critical",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/select-name?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<select id=\"lang\" name=\"lang\" onchange=\"return onLangChange(this)\" style=\"font-size: 10px;\">"
+        }
+      ]
+    }
+  ]
+}

package/__mocks__/mock_all_issues/000000002.json

@@ -0,0 +1,53 @@
+{
+  "url": "https://www.sitemaps.org/faq.html",
+  "page": "/faq.html",
+  "errors": [
+    {
+      "id": "color-contrast",
+      "description": "Elements must have sufficient color contrast",
+      "impact": "serious",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/color-contrast?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<p class=\"date\">\n\n                Last Updated: Monday, November 21, 2016\n\n            </p>"
+        }
+      ]
+    },
+    {
+      "id": "html-has-lang",
+      "description": "<html> element must have a lang attribute",
+      "impact": "serious",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/html-has-lang?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" id=\"sitemaps_org\">"
+        }
+      ]
+    },
+    {
+      "id": "landmark-one-main",
+      "description": "Document should have one main landmark",
+      "impact": "moderate",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/landmark-one-main?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" id=\"sitemaps_org\">"
+        }
+      ]
+    },
+    {
+      "id": "region",
+      "description": "All page content should be contained by landmarks",
+      "impact": "moderate",
+      "helpUrl": "https://dequeuniversity.com/rules/axe/4.2/region?application=oobee",
+      "fixes": [
+        {
+          "htmlElement": "<div id=\"container\">"
+        },
+        {
+          "htmlElement": "<div id=\"footer\">\n\n        <p>\n\n            <a href=\"terms.php\">Terms and conditions</a></p>\n\n    </div>"
+        }
+      ]
+    }
+  ]
+}

package/__tests__/logs.test.ts

@@ -0,0 +1,25 @@
+/* eslint-disable no-undef */
+import {jest} from '@jest/globals'
+import winston from 'winston';
+import { logFormat } from '../logs.js';
+
+describe('test log format', () => {
+  afterEach(() => {
+    jest.resetModules();
+  });
+
+  test('should return expected log format', () => {
+    const mockFormatInfo = {
+      level: 'info',
+      message: `unit-test-message`,
+    };
+
+    const result = winston.format.printf(logFormat.template(mockFormatInfo));
+    expect(typeof result).toBe('object');
+    expect(JSON.parse(result.template).level).toEqual('info');
+    expect(JSON.parse(result.template).message).toEqual('unit-test-message');
+    expect(
+      Object.prototype.hasOwnProperty.call(JSON.parse(result.template), 'timestamp'),
+    ).toBeTruthy();
+  });
+});

package/__tests__/mergeAxeResults.test.ts

@@ -0,0 +1,278 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-undef */
+import { jest } from '@jest/globals';
+import printMessage from 'print-message';
+import fs from 'fs-extra';
+import path from 'path';
+import Mustache from 'mustache';
+
+import privateFuncs from '../mergeAxeResults.js';
+
+const issueCountMap = privateFuncs.__get__('issueCountMap');
+const thresholdLimitCheck = privateFuncs.__get__('thresholdLimitCheck');
+const extractFileNames = privateFuncs.__get__('extractFileNames');
+const parseContentToJson = privateFuncs.__get__('parseContentToJson');
+const granularReporting = privateFuncs.__get__('granularReporting');
+const writeHTML = privateFuncs.__get__('writeHTML');
+const writeResults = privateFuncs.__get__('writeResults');
+
+const {
+  allIssues,
+  allExceptCritical,
+  allExceptModerate,
+  allExceptSerious,
+  allExceptMinor,
+  criticalOnly,
+  seriousOnly,
+  moderateOnly,
+  minorOnly,
+} = require('../__mocks__/mockIssues');
+
+const {
+  createIssueCountMap,
+  createAlertMessage,
+  createFilenames,
+  createFinalResultsInJson,
+} = require('../__mocks__/mockFunctions');
+const { getCurrentDate, getFormattedTime } = require('../utils');
+const { consoleLogger, silentLogger } = require('../logs');
+
+let randomToken;
+let currentDate;
+let expectedStoragePath;
+let expectedJsonFilename;
+let expectedHTMLFilename;
+let htmlFilename;
+let jsonFilename;
+
+jest.mock('print-message');
+jest.mock('fs-extra');
+jest.mock('mustache');
+
+beforeEach(() => {
+  randomToken = '162282454060d4c8470d';
+  currentDate = getCurrentDate();
+  expectedStoragePath = `results/${currentDate}/${randomToken}`;
+
+  // Reports storagePath, expected report and compiled result files
+  htmlFilename = 'report';
+  expectedHTMLFilename = `${expectedStoragePath}/${htmlFilename}.html`;
+
+  // Mock the JSON result generated from the issues
+  dateTimeStamp = getFormattedTime();
+  jsonOutput = createFinalResultsInJson(allIssues, dateTimeStamp);
+});
+
+// Test issueCountMap
+describe('test breakdown of issue counts', () => {
+  test('should return map of 0 for no issues', () => {
+    const result = issueCountMap([]);
+    expect(result).toEqual(
+      new Map([
+        ['critical', 0],
+        ['serious', 0],
+        ['moderate', 0],
+        ['minor', 0],
+        ['total', 0],
+      ]),
+    );
+  });
+
+  test('should return map of issue counts', () => {
+    const result = issueCountMap(allIssues);
+    expect(result).toEqual(
+      new Map([
+        ['critical', 1],
+        ['serious', 1],
+        ['moderate', 1],
+        ['minor', 1],
+        ['total', 4],
+      ]),
+    );
+  });
+});
+
+// Test thresholdLimitCheck
+describe('test threshold limit check', () => {
+  const mockIssueCountMap = mockData => {
+    privateFuncs.__set__('issueCountMap', mockData)();
+  };
+
+  beforeEach(() => {
+    warnlevel = 'none';
+    expectedIssueCountMap = [];
+  });
+
+  afterEach(() => {
+    printMessage.mockReset();
+  });
+
+  test('should print issue count with no trigger if warnlevel is none', async () => {
+    expectedIssueCountMap = createIssueCountMap(1, 1, 1, 1);
+    mockIssueCountMap(expectedIssueCountMap);
+
+    await thresholdLimitCheck(warnlevel, allIssues);
+    expect(printMessage).toHaveBeenCalled();
+    expect(printMessage.mock.calls.length).toEqual(1);
+    expect(printMessage.mock.calls[0][0]).toEqual(expectedIssueCountMap);
+  });
+
+  test.each([
+    ['critical', allExceptCritical, createIssueCountMap(0, 1, 1, 1)],
+    ['serious', allExceptSerious, createIssueCountMap(1, 0, 1, 1)],
+    ['moderate', allExceptModerate, createIssueCountMap(1, 1, 0, 1)],
+    ['minor', allExceptMinor, createIssueCountMap(1, 1, 1, 0)],
+  ])(
+    'should print issue count only if all issues except %s issues are present',
+    async (warnlevel, data, expected) => {
+      mockIssueCountMap(data);
+
+      await thresholdLimitCheck(warnlevel, data);
+      expect(printMessage).toHaveBeenCalled();
+      expect(printMessage.mock.calls.length).toEqual(1);
+      expect(printMessage.mock.calls[0][0]).toEqual(expected);
+    },
+  );
+
+  test.each([
+    ['critical', criticalOnly, createIssueCountMap(1, 0, 0, 0)],
+    ['serious', seriousOnly, createIssueCountMap(0, 1, 0, 0)],
+    ['moderate', moderateOnly, createIssueCountMap(0, 0, 1, 0)],
+    ['minor', minorOnly, createIssueCountMap(0, 0, 0, 1)],
+  ])(
+    'should print issue count and alert message if %s issues are present',
+    async (warnlevel, data, expected) => {
+      const expectedAlertMessage = createAlertMessage(warnlevel);
+      mockIssueCountMap(data);
+
+      await thresholdLimitCheck(warnlevel, data);
+      expect(printMessage).toHaveBeenCalled();
+      expect(printMessage.mock.calls.length).toEqual(2);
+      expect(printMessage.mock.calls[0][0]).toEqual(expected);
+      expect(printMessage.mock.calls[1]).toEqual(expectedAlertMessage);
+    },
+  );
+});
+
+describe('test parsing content to json', () => {
+  test('should return JSON', async () => {
+    fs.readFile.mockResolvedValue('{ "a": 1 }');
+    const expected = { a: 1 };
+    const result = await parseContentToJson('path');
+    expect(result).toMatchObject(expected);
+  });
+
+  test('should print error message when unable to parse content', async () => {
+    fs.readFile.mockResolvedValue(undefined);
+    await parseContentToJson('path');
+    const spyConsoleLogger = jest.spyOn(consoleLogger, 'info').mockImplementation();
+    const spySilentLogger = jest.spyOn(silentLogger, 'error').mockImplementation();
+
+    expect(spyConsoleLogger.mock.calls[0][0]).toEqual(
+      'An error has occurred when parsing the content, please try again.',
+    );
+
+    expect(spySilentLogger.mock.calls[0][0].toString()).toMatch(
+      new RegExp(/SyntaxError\:[\s]+Unexpected token.*JSON/),
+    );
+  });
+});
+
+describe('test write results', () => {
+  afterEach(() => {
+    fs.writeFile.mockReset();
+  });
+
+  test('should create compiled json file with intended filename', async () => {
+    fs.writeFile.mockResolvedValue();
+    await writeResults(allIssues, expectedStoragePath, jsonFilename);
+
+    expect(fs.writeFile).toHaveBeenCalled();
+    expect(fs.writeFile.mock.calls[0][0]).toEqual(expectedJsonFilename);
+    expect(fs.writeFile.mock.calls[0][1]).toEqual(jsonOutput);
+  });
+
+  test('should fail if there is error writing to JSON file', async () => {
+    fs.writeFile.mockImplementation(() => {
+      throw new Error();
+    });
+
+    const spyConsoleLogger = jest.spyOn(consoleLogger, 'info').mockImplementation();
+    const spySilentLogger = jest.spyOn(silentLogger, 'error').mockImplementation();
+
+    await writeResults(allIssues, expectedStoragePath, jsonFilename);
+    expect(fs.writeFile).toThrowError();
+    expect(spyConsoleLogger.mock.calls[0][0]).toEqual(
+      'An error has occurred when compiling the results into the report, please try again.',
+    );
+    expect(spySilentLogger.mock.calls[0][0].toString()).toEqual('(writeResults) - Error');
+  });
+});
+
+describe('test write results into HTML report', () => {
+  beforeAll(() => {
+    // Reports Templates and Content
+    const originalFs = jest.requireActual('fs-extra');
+    const mustacheReportfile = path.resolve('./static/report.mustache');
+    const mockReportFile = path.resolve('./__mocks__/mock-report.html');
+
+    mustacheTemp = originalFs.readFileSync(mustacheReportfile, 'utf8', data => data);
+    mockReportContent = originalFs.readFileSync(mockReportFile, 'utf8', data => data);
+  });
+
+  afterEach(() => {
+    fs.readFile.mockReset();
+    fs.writeFile.mockReset();
+    Mustache.render.mockReset();
+  });
+
+  test('should create HTML report with intended filename', async () => {
+    fs.readFile.mockResolvedValue(mustacheTemp);
+    Mustache.render.mockResolvedValue(mockReportContent);
+    await writeHTML(allIssues, expectedStoragePath, htmlFilename);
+
+    expect(fs.readFile).toHaveBeenCalled();
+    expect(Mustache.render).toHaveBeenCalled();
+    expect(fs.writeFile).toHaveBeenCalled();
+
+    expect(fs.readFile.mock.results[0].value).resolves.toEqual(mustacheTemp);
+    expect(Mustache.render.mock.results[0].value).resolves.toEqual(mockReportContent);
+    expect(fs.writeFile.mock.calls[0][0]).toEqual(expectedHTMLFilename);
+    expect(fs.writeFile.mock.calls[0][1]).resolves.toEqual(mockReportContent);
+  });
+
+  test('should fail if unable to read the template file', async () => {
+    fs.readFile.mockImplementation(() => {
+      throw new Error();
+    });
+
+    const spyConsoleLogger = jest.spyOn(consoleLogger, 'info').mockImplementation();
+    const spySilentLogger = jest.spyOn(silentLogger, 'error').mockImplementation();
+    await writeHTML(allIssues, expectedStoragePath, htmlFilename);
+    expect(fs.readFile).toThrowError();
+    expect(spyConsoleLogger.mock.calls[0][0]).toEqual(
+      'An error has occurred when generating the report, please try again.',
+    );
+    expect(spySilentLogger.mock.calls[0][0].toString()).toEqual('(writeHTML) - Error');
+  });
+});
+
+describe('test granular reporting feature', () => {
+  afterEach(() => {
+    privateFuncs.__get__('writeHTML');
+    privateFuncs.__get__('writeResults');
+  });
+
+  test('should return false when there are no issues', async () => {
+    const noIssues = [];
+    const result = await granularReporting(randomToken, noIssues);
+    expect(result).toBe(false);
+  });
+
+  test('should return true and generate the graular reports along with main reports', async () => {
+    privateFuncs.__set__('writeResults', jest.fn());
+    privateFuncs.__set__('writeHTML', jest.fn());
+    const result = await granularReporting(randomToken, allIssues);
+    expect(result).toBe(true);
+  });
+});

package/__tests__/utils.test.ts

@@ -0,0 +1,118 @@
+/* eslint-disable no-undef */
+import {jest} from '@jest/globals'
+import {
+  setThresholdLimits,
+  getHost,
+  getCurrentDate,
+  validateUrl,
+  getStoragePath,
+  setHeadlessMode,
+} from '../utils.js';
+
+describe('test setting of threshold warn level', () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+  });
+
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+
+  test.each([
+    ['critical', 'critical'],
+    ['serious', 'serious'],
+    ['moderate', 'moderate'],
+    ['minor', 'minor'],
+    ['none', 'none'],
+  ])('should set warn level as %s', (warnLevel, expected) => {
+    setThresholdLimits(warnLevel);
+    expect(process.env.WARN_LEVEL).toBe(expected);
+  });
+});
+
+describe('test getHost', () => {
+  test('should retrieve the hostnames accordingly', () => {
+    expect(getHost('https://www.bbc.com/news')).toEqual('www.bbc.com');
+    expect(getHost('https://www.isomer.gov.sg/')).toEqual('www.isomer.gov.sg');
+    expect(getHost('https://fontawesome.com/sessions/sign-in')).toEqual(
+      'fontawesome.com',
+    );
+    // port number will be excluded since it is the default port for HTTPS
+    expect(getHost('https://www.crowdtask.gov.sg:443')).toEqual('www.crowdtask.gov.sg');
+    expect(getHost('http://localhost:5000/about/me')).toEqual('localhost:5000');
+  });
+});
+
+describe('test getCurrentDate', () => {
+  const mockDate = new Date('December 17, 1995');
+  jest.spyOn(global, 'Date').mockImplementation(() => mockDate);
+
+  test('should return date in string "1995-12-17"', () => {
+    expect(getCurrentDate()).toEqual('1995-12-17');
+  });
+});
+
+describe('test validateUrl', () => {
+  test('urls should pass', () => {
+    expect(validateUrl('https://www.bbc.com/news')).toEqual(true);
+    expect(validateUrl('https://www.isomer.gov.sg/')).toEqual(true);
+    expect(validateUrl('https://www.bbc.com/')).toEqual(true);
+  });
+
+  test('urls should fail', () => {
+    expect(validateUrl('https://www.bbc.gif')).toEqual(false);
+    expect(validateUrl('https://www.bbc.jpg')).toEqual(false);
+    expect(validateUrl('https://www.bbc.jpeg')).toEqual(false);
+    expect(validateUrl('https://www.bbc.png')).toEqual(false);
+    expect(validateUrl('https://www.bbc.pdf')).toEqual(false);
+    expect(validateUrl('https://www.bbc.doc')).toEqual(false);
+    expect(validateUrl('https://www.bbc.css')).toEqual(false);
+    expect(validateUrl('https://www.bbc.svg')).toEqual(false);
+    expect(validateUrl('https://www.bbc.js')).toEqual(false);
+    expect(validateUrl('https://www.bbc.ts')).toEqual(false);
+    expect(validateUrl('https://www.bbc.xml')).toEqual(false);
+    expect(validateUrl('https://www.bbc.csv')).toEqual(false);
+    expect(validateUrl('https://www.bbc.tgz')).toEqual(false);
+    expect(validateUrl('https://www.bbc.zip')).toEqual(false);
+    expect(validateUrl('https://www.bbc.xls')).toEqual(false);
+    expect(validateUrl('https://www.bbc.ppt')).toEqual(false);
+    expect(validateUrl('https://www.bbc.ico')).toEqual(false);
+    expect(validateUrl('https://www.bbc.woff')).toEqual(false);
+    expect(validateURL('https://www.bbc.webp')).toEqual(false);
+  });
+});
+
+describe('test getStoragePath', () => {
+  jest.mock('../utils', () => ({
+    getCurrentDate: '1995-12-17',
+  }));
+  const mockRandomToken = 'token123';
+  test('should return "results/1995-12-17/token123"', () => {
+    expect(getStoragePath(mockRandomToken)).toEqual(`results/1995-12-17/${mockRandomToken}`);
+  });
+});
+
+describe('test setHeadlessMode', () => {
+  test('should headlessMode is true', () => {
+    setHeadlessMode(true);
+    expect(process.env.CRAWLEE_HEADLESS).toEqual('1');
+  });
+  test('should headlessMode is false', () => {
+    setHeadlessMode(false);
+    expect(process.env.CRAWLEE_HEADLESS).toEqual('0');
+  });
+});
+
+describe('test setHeadlessMode', () => {
+  test('should headlessMode is true', () => {
+    setHeadlessMode(true);
+    expect(process.env.CRAWLEE_HEADLESS).toEqual('1');
+  });
+  test('should headlessMode is false', () => {
+    setHeadlessMode(false);
+    expect(process.env.CRAWLEE_HEADLESS).toEqual('0');
+  });
+});