split tests

Author: zendive

jest/tests/AnimationWrapper.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test, beforeEach, afterEach } from '@jest/globals';
+import { AnimationWrapper } from '../../src/wrapper/AnimationWrapper.ts';
+import { TraceUtil } from '../../src/wrapper/TraceUtil.ts';
+import { TAG_EXCEPTION } from '../../src/api/clone.ts';
+import { TextEncoder } from 'node:util';
+
+global.TextEncoder = TextEncoder;
+
+describe('AnimationWrapper', () => {
+  const traceUtil = new TraceUtil();
+  let apiAnimation: AnimationWrapper;
+
+  beforeEach(() => {
+    apiAnimation = new AnimationWrapper(traceUtil);
+    apiAnimation.wrapRequestAnimationFrame();
+    apiAnimation.wrapCancelAnimationFrame();
+  });
+
+  afterEach(() => {
+    apiAnimation.unwrapRequestAnimationFrame();
+    apiAnimation.unwrapCancelAnimationFrame();
+  });
+
+  test('rafHistory - recorded', async () => {
+    let typeOfArgument = '';
+    const handler = await new Promise((resolve) => {
+      const handler = requestAnimationFrame((time) => {
+        typeOfArgument = typeof time;
+        resolve(handler);
+      });
+    });
+    const rec = Array.from(apiAnimation.rafHistory.values())[0];
+
+    expect(typeOfArgument).toBe('number');
+    expect(apiAnimation.rafHistory.size).toBe(1);
+    expect(rec.handler).toBe(handler);
+    expect(rec.calls).toBe(1);
+    expect(rec.trace.length).toBeGreaterThan(1);
+    expect(rec.traceId.length).toBeGreaterThan(1);
+    expect(rec.selfTime).not.toBeNull();
+    expect(apiAnimation.callCounter.requestAnimationFrame).toBe(1);
+  });
+
+  test('cafHistory - recorded', async () => {
+    const unchanged = 0,
+      changed = 1;
+    let changeable = unchanged;
+    const handler = requestAnimationFrame(() => {
+      changeable = changed;
+    });
+    cancelAnimationFrame(handler);
+
+    const rafRec = Array.from(apiAnimation.rafHistory.values())[0];
+    const cafRec = Array.from(apiAnimation.cafHistory.values())[0];
+
+    expect(changeable).toBe(unchanged);
+    expect(apiAnimation.rafHistory.size).toBe(1);
+    expect(apiAnimation.cafHistory.size).toBe(1);
+    expect(cafRec.handler).toBe(handler);
+    expect(cafRec.calls).toBe(1);
+    expect(cafRec.trace.length).toBeGreaterThan(1);
+    expect(cafRec.traceId.length).toBeGreaterThan(1);
+    expect(apiAnimation.callCounter.cancelAnimationFrame).toBe(1);
+    expect(rafRec.canceledByTraceIds?.length).toBe(1);
+    expect(rafRec.canceledCounter).toBe(1);
+  });
+
+  test('cafHistory - invalid handler', () => {
+    cancelAnimationFrame(0);
+
+    const rec = Array.from(apiAnimation.cafHistory?.values())[0];
+
+    expect(rec.handler).toBe(TAG_EXCEPTION(0));
+  });
+});

jest/tests/EvalWrapper.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test, beforeEach, afterEach } from '@jest/globals';
+import { EvalWrapper } from '../../src/wrapper/EvalWrapper.ts';
+import { TimerWrapper } from '../../src/wrapper/TimerWrapper.ts';
+import { TraceUtil } from '../../src/wrapper/TraceUtil.ts';
+import { TAG_UNDEFINED } from '../../src/api/clone.ts';
+import { TextEncoder } from 'node:util';
+import {
+  TAG_EVAL_RETURN_SET_INTERVAL,
+  TAG_EVAL_RETURN_SET_TIMEOUT,
+} from '../../src/api/const.ts';
+
+global.TextEncoder = TextEncoder;
+
+describe('EvalWrapper', () => {
+  const traceUtil = new TraceUtil();
+  let apiEval: EvalWrapper;
+  let apiTimer: TimerWrapper;
+
+  beforeEach(() => {
+    apiEval = new EvalWrapper(traceUtil);
+    apiEval.wrap();
+    apiTimer = new TimerWrapper(traceUtil, apiEval);
+    apiTimer.wrapSetTimeout();
+    apiTimer.wrapSetInterval();
+  });
+
+  afterEach(() => {
+    apiEval.unwrap();
+    apiTimer.unwrapSetTimeout();
+    apiTimer.unwrapSetInterval();
+  });
+
+  test('evalHistory - recorded', () => {
+    const NUMBER_OF_INVOCATIONS = 2;
+    const CODE = '(1+2)';
+    const RESULT = 3;
+
+    for (let i = 0, I = NUMBER_OF_INVOCATIONS; i < I; i++) {
+      window.eval(CODE);
+    }
+    expect(apiEval.evalHistory.size).toBe(1);
+
+    const rec = Array.from(apiEval.evalHistory.values())[0];
+
+    expect(rec.calls).toBe(NUMBER_OF_INVOCATIONS);
+    expect(rec.usesLocalScope).toBe(false);
+    expect(rec.code).toBe(CODE);
+    expect(rec.returnedValue).toBe(RESULT);
+    expect(rec.trace.length).toBeGreaterThan(1);
+    expect(rec.traceId.length).toBeGreaterThan(0);
+    expect(rec.selfTime).not.toBeNull();
+  });
+
+  test('evalHistory - detects local scope usage', () => {
+    const local_variable = 0;
+    window.eval('(local_variable++)');
+
+    const rec = Array.from(apiEval.evalHistory.values())[0];
+
+    expect(rec.calls).toBe(1);
+    expect(local_variable).toBe(0);
+    expect(rec.usesLocalScope).toBe(true);
+    expect(rec.returnedValue).toBe(TAG_UNDEFINED);
+  });
+
+  test('setTimeoutHistory - isEval recorded', () => {
+    const CODE = '(1+2)';
+    setTimeout(CODE);
+    const timerRec = Array.from(apiTimer.setTimeoutHistory.values())[0];
+    const evalRec = Array.from(apiEval.evalHistory.values())[0];
+
+    expect(timerRec.isEval).toBe(true);
+    expect(evalRec.code).toBe(CODE);
+    expect(evalRec.returnedValue).toBe(TAG_EVAL_RETURN_SET_TIMEOUT);
+  });
+
+  test('setIntervalHistory - isEval recorded', () => {
+    const CODE = '(1+2)';
+    const handler = setInterval(CODE, 123);
+    const timerRec = Array.from(apiTimer.setIntervalHistory.values())[0];
+    const evalRec = Array.from(apiEval.evalHistory.values())[0];
+
+    expect(timerRec.isEval).toBe(true);
+    expect(evalRec.code).toBe(CODE);
+    expect(evalRec.returnedValue).toBe(TAG_EVAL_RETURN_SET_INTERVAL);
+
+    clearInterval(handler);
+  });
+});