@testgorilla/tgo-coding-test 0.0.1

package/src/lib/services/candidate-coding-test-services/coding-test.service.spec.ts

@@ -0,0 +1,1524 @@
+import { fakeAsync, flush, TestBed, tick } from '@angular/core/testing';
+import {
+  ConfirmDialogComponent,
+  DialogComponentModule,
+  DialogService,
+  SnackbarService,
+} from '@testgorilla/tgo-ui';
+import {
+  getTranslocoModule,
+  MixpanelService,
+  TestResultRead,
+} from '@testgorilla/tgo-test-shared';
+import { asyncScheduler, Observable, of, scheduled, Subject } from 'rxjs';
+
+import { MatDialogRef } from '@angular/material/dialog';
+import { CodingTestsResultsModel } from '../../models/coderunner-execution-results';
+import { ProgrammingLanguageVersioned } from '../../models/programming-language';
+import { SqlTestCase } from '../../models/test-cases';
+import { LibCodingTestService } from '../lib-coding-test.service';
+import { ResetCodeAction } from '../lib-coding-test.service';
+import { TestCaseDeletionAction } from '../../models/test-cases';
+import { TestCaseDeletionData } from '../../models/test-cases';
+import { CoderunnerApiService } from './coderunner-api.service';
+import { CodingTestService } from './coding-test.service';
+
+class MixpanelServiceMock {
+  track = jest.fn();
+}
+
+describe('CodingTestService', () => {
+  let service: CodingTestService;
+  let libCodingTestService: LibCodingTestService;
+  let coderunnerApiService: CoderunnerApiService;
+  let mixpanelService: MixpanelService;
+  let dialogSpy: jest.SpyInstance;
+  const companyColor = '#D410AA';
+  const afterClosedResult = of(true);
+  const afterClosedResultCancel = of(false);
+  const dialogRefSpy = {
+    afterClosed: jest.fn(() => afterClosedResult),
+  } as unknown as MatDialogRef<unknown>;
+  const dialogRefSpyCancel = {
+    afterClosed: jest.fn(() => afterClosedResultCancel),
+  } as unknown as MatDialogRef<unknown>;
+  let confirmResetSpy: jest.SpyInstance;
+  const LATlanguage = 'python';
+  const LATversion = '3.10.0';
+  const fullProgrammingLang = {
+    id: 1,
+    name: LATlanguage,
+    version: LATversion,
+  };
+  const defaultProgrammingLang = {
+    id: 2,
+    name: 'javascript',
+    version: '1.2.3',
+  };
+  const testCaseDeletionSubj$ = new Subject<TestCaseDeletionData>();
+  const libCodingTestServiceMock = {
+    confirmReset: jest.fn(),
+    codeReset$: scheduled(of(ResetCodeAction.Try), asyncScheduler),
+    configFieldChanged$: of(null),
+    currentLanguage$: of(LATlanguage),
+    getVersion: jest.fn(() => LATversion),
+    getValidTestCases: jest.fn(() => [
+      {
+        id: 1,
+        name: 'Example 1',
+        input: '1\n2\n2',
+        expectedOutput: '0 1 0',
+        preloaded: true,
+      },
+      {
+        name: 'Test 1',
+        input: '1\n2\n3',
+        expectedOutput: '0 1 1',
+        preloaded: true,
+      },
+      {
+        name: 'Custom 1',
+        input: 'Custom 1',
+        expectedOutput: '0 1 0',
+        preloaded: false,
+      },
+      {
+        name: 'Custom 2',
+        input: 'Custom 2',
+        expectedOutput: '0 1 1',
+        preloaded: false,
+      },
+    ]),
+    getTestCasesCount: jest.fn(() => 6),
+    confirmLanguageChange: jest.fn(),
+    cancelLanguageChange: jest.fn(),
+    testCaseDeletion$: testCaseDeletionSubj$.asObservable(),
+    confirmTestCaseDeletion: jest.fn(),
+  };
+  let runTestResponse: Record<string, unknown> = {};
+  let LATResultsValue: CodingTestsResultsModel;
+  let SQLResultsValue: CodingTestsResultsModel;
+  const resultId = 1;
+  const testResultId = 1;
+  const id = 123;
+  const code = 'lorem';
+  const executedSuccessfullyCopyPath =
+    'CODING_QUESTION.CODING_LIB.TEST_RESULTS.TEST_CASES.EXECUTED_SUCCESSFULLY';
+  const sqlexecutedSuccessfullyCopyPath =
+    'CODING_QUESTION.CODING_LIB.TEST_RESULTS.TEST_CASES.SQL_EXECUTED_SUCCESSFULLY';
+  const noneOutputCopyPath =
+    'CODING_QUESTION.CODING_LIB.TEST_RESULTS.TEST_CASES.NONE';
+  const noResponseOutputCopyPath =
+    'CODING_QUESTION.CODING_LIB.TEST_RESULTS.TEST_CASES.NO_RESPONSE';
+  const timeoutErrorCopyPath =
+    'CODING_QUESTION.CODING_LIB.TEST_RESULTS.TEST_CASES.TIMEOUT_ERROR';
+
+  jest.mock('@ngneat/transloco', () => ({
+    translate: (key: string) => key,
+  }));
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [DialogComponentModule, getTranslocoModule()],
+      providers: [
+        CodingTestService,
+        {
+          provide: LibCodingTestService,
+          useValue: libCodingTestServiceMock,
+        },
+        {
+          provide: CoderunnerApiService,
+          useValue: {
+            runPublicTest$: jest.fn().mockReturnValue(of(runTestResponse)),
+            runPreviewTest$: jest.fn().mockReturnValue(of(runTestResponse)),
+            runNonPreviewTest$: jest.fn().mockReturnValue(of(runTestResponse)),
+            sendCodeEvent$: jest.fn().mockReturnValue(of({})),
+          },
+        },
+        {
+          provide: SnackbarService,
+          useValue: {
+            open: jest.fn(),
+          },
+        },
+        {
+          provide: MixpanelService,
+          useClass: MixpanelServiceMock,
+        },
+      ],
+    });
+  });
+
+  beforeEach(() => {
+    service = TestBed.inject(CodingTestService);
+    libCodingTestService = TestBed.inject(LibCodingTestService);
+    coderunnerApiService = TestBed.inject(CoderunnerApiService);
+    mixpanelService = TestBed.inject(MixpanelService);
+
+    confirmResetSpy = jest.spyOn(libCodingTestService, 'confirmReset');
+    runTestResponse = {};
+    service.setCurrentLanguageLAT(defaultProgrammingLang);
+  });
+
+  describe('when transformToExampleLATtestCase is called', () => {
+    it('should return example test case', () => {
+      const testCase = {
+        id: 1,
+        input: 'Custom 1',
+        name: '',
+        solution: '0 1 0',
+      };
+      const exampleTestCase = service.transformToExampleLATtestCase(
+        testCase,
+        0
+      );
+      const expectedTestCase = {
+        id: 1,
+        name: 'Example 1',
+        input: 'Custom 1',
+        expectedOutput: '0 1 0',
+        preloaded: true,
+      };
+
+      expect(exampleTestCase).toEqual(expectedTestCase);
+    });
+  });
+
+  describe('when setSqlTestCases is called', () => {
+    it('should set sqlTestCases', () => {
+      const testCase = {
+        id: 1,
+        name: '',
+        category: 'user',
+      };
+      service.setSqlTestCases([testCase as SqlTestCase]);
+
+      expect(service.getSqlTestCases()).toContain(testCase);
+    });
+  });
+
+  describe('when handler for reset code modal is called', () => {
+    const context = 'CODING_QUESTION.MODALS.RESET_CODE.';
+    const modalData = {
+      confirmButtonText: `${context}SUBMIT`,
+      message: `${context}MESSAGE`,
+      title: `${context}TITLE`,
+      color: companyColor,
+    };
+    const applicationTheme = 'dark';
+    const modalSize = 'small';
+
+    beforeEach(() => {
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpy);
+    });
+
+    it('should open Dialog', () => {
+      service.handleResetCodeModal(applicationTheme, companyColor);
+      expect(dialogSpy).toHaveBeenCalledWith(ConfirmDialogComponent, {
+        applicationTheme: applicationTheme,
+        size: modalSize,
+        extraData: modalData,
+      });
+    });
+
+    it('should call confirm reset if modal is closed with confirmation', () => {
+      service.handleResetCodeModal(applicationTheme, companyColor);
+      expect(dialogRefSpy.afterClosed).toHaveBeenCalled();
+      expect(confirmResetSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('when listenDeleteCustomTestCases is called', () => {
+    it('should return testCaseDeletion$ observable with only Try action', (done) => {
+      service.listenDeleteCustomTestCases().subscribe(({ action }) => {
+        expect(action).toBe(TestCaseDeletionAction.Try);
+        done();
+      });
+
+      testCaseDeletionSubj$.next({
+        action: TestCaseDeletionAction.Try,
+        index: 1,
+      });
+    });
+  });
+
+  describe('when handleDeleteTestCaseModal is called', () => {
+    const context = 'CODING_QUESTION.MODALS.DELETE_TEST_CASE.';
+    const modalData = {
+      confirmButtonText: `${context}SUBMIT`,
+      message: `${context}MESSAGE`,
+      title: `${context}TITLE`,
+      color: companyColor,
+    };
+
+    let confirmTestCaseDeletionSpy: jest.SpyInstance;
+    const applicationTheme = 'dark';
+    const modalSize = 'small';
+
+    beforeEach(() => {
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpy);
+      confirmTestCaseDeletionSpy = jest.spyOn(
+        libCodingTestService,
+        'confirmTestCaseDeletion'
+      );
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should open Dialog', () => {
+      const index = 3;
+
+      service.handleDeleteTestCaseModal(index, applicationTheme, companyColor);
+
+      expect(dialogSpy).toHaveBeenCalledWith(ConfirmDialogComponent, {
+        applicationTheme: applicationTheme,
+        size: modalSize,
+        extraData: modalData,
+      });
+    });
+
+    it('should call confirmTestCaseDeletion if modal is closed with confirmation', () => {
+      const index = 3;
+
+      service.handleDeleteTestCaseModal(index, applicationTheme, companyColor);
+
+      expect(dialogRefSpy.afterClosed).toHaveBeenCalled();
+      expect(confirmTestCaseDeletionSpy).toHaveBeenCalled();
+    });
+
+    it('should call cancelLanguageChange if modal is closed with cancellation', () => {
+      const index = 3;
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpyCancel);
+
+      service.handleDeleteTestCaseModal(index, applicationTheme, companyColor);
+
+      expect(dialogRefSpyCancel.afterClosed).toHaveBeenCalled();
+      expect(confirmTestCaseDeletionSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when handler for language change modal is called', () => {
+    const context = 'CODING_QUESTION.MODALS.LANGUAGE_CHANGE.';
+    const modalData = {
+      confirmButtonText: `${context}SUBMIT`,
+      message: `${context}MESSAGE`,
+      title: `${context}TITLE`,
+    };
+    const defaultApplicationTheme = 'light';
+    const modalSize = 'small';
+
+    let confirmLanguageChangeSpy: jest.SpyInstance;
+    let cancelLanguageChangeSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      confirmLanguageChangeSpy = jest.spyOn(
+        libCodingTestService,
+        'confirmLanguageChange'
+      );
+      cancelLanguageChangeSpy = jest.spyOn(
+        libCodingTestService,
+        'cancelLanguageChange'
+      );
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should open Dialog', () => {
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpy);
+      service.handleLanguageChangeModal(0);
+      expect(dialogSpy).toHaveBeenCalledWith(ConfirmDialogComponent, {
+        applicationTheme: defaultApplicationTheme,
+        size: modalSize,
+        extraData: modalData,
+      });
+    });
+
+    it('should call confirmLanguageChange if modal is closed with confirmation', () => {
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpy);
+      service.handleLanguageChangeModal(0);
+      expect(dialogRefSpy.afterClosed).toHaveBeenCalled();
+      expect(confirmLanguageChangeSpy).toHaveBeenCalled();
+      expect(cancelLanguageChangeSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call cancelLanguageChange if modal is closed with cancellation', () => {
+      dialogSpy = jest
+        .spyOn(TestBed.inject(DialogService), 'open')
+        .mockReturnValue(dialogRefSpyCancel);
+      service.handleLanguageChangeModal(0);
+      expect(dialogRefSpyCancel.afterClosed).toHaveBeenCalled();
+      expect(confirmLanguageChangeSpy).not.toHaveBeenCalled();
+      expect(cancelLanguageChangeSpy).toHaveBeenCalled();
+    });
+
+    describe('and selectedLanguage is passed', () => {
+      it('should call setCurrentLanguageLAT with passed language', () => {
+        const setLangSpy = jest.spyOn(service, 'setCurrentLanguageLAT');
+        dialogSpy = jest
+          .spyOn(TestBed.inject(DialogService), 'open')
+          .mockReturnValue(dialogRefSpy);
+        service.handleLanguageChangeModal(0, fullProgrammingLang);
+        expect(confirmLanguageChangeSpy).toHaveBeenCalled();
+        expect(setLangSpy).toHaveBeenCalledWith(fullProgrammingLang);
+      });
+    });
+  });
+
+  describe('when setCurrentLanguageLAT is called', () => {
+    it('should set current language', () => {
+      service.setCurrentLanguageLAT(fullProgrammingLang);
+      expect(service['currentLanguage']).toEqual(fullProgrammingLang);
+    });
+  });
+
+  describe('when listener for coding changes is called', () => {
+    it('should return an observable with ResetCodeAction.Try', (done) => {
+      service.listenCodingTestChanges().subscribe((value) => {
+        expect(value).toEqual(ResetCodeAction.Try);
+        done();
+      });
+    });
+  });
+
+  describe('when runTest() is called', () => {
+    it('should set loading results to true', () => {
+      service.runTest(resultId, 'lorem', false);
+
+      expect(service.isTestResultsLoading()).toBeTruthy();
+    });
+
+    it('should reset summary', fakeAsync(() => {
+      const spy = jest.spyOn(service, 'resetRunTestSummary');
+
+      service.runTest(resultId, code, false);
+      tick();
+
+      expect(spy).toHaveBeenCalled();
+      flush();
+    }));
+
+    describe('and isSQL === true', () => {
+      const attemptId = '12345';
+      let runTestData;
+      const sqlTestCases: SqlTestCase[] = [
+        {
+          id: 1,
+          name: 'Passing Test',
+          category: 'user',
+          initial_sql:
+            'CREATE TABLE test_table (id INTEGER PRIMARY KEY, value TEXT);',
+          pre_sql: "INSERT INTO test_table VALUES (1, 'Hello'), (2, 'World');",
+          post_sql: '',
+          result: "'Hello', 'World'",
+        },
+        {
+          id: 2,
+          name: 'Failing Test',
+          category: 'user',
+          initial_sql:
+            'CREATE TABLE test_table (id INTEGER PRIMARY KEY, value TEXT);',
+          pre_sql: "INSERT INTO test_table VALUES (1, 'Hello'), (2, 'World');",
+          post_sql: 'SELECT * FROM',
+          result: "'Goodbye', 'Everyone'",
+        },
+      ];
+      beforeEach(() => {
+        service.setSqlTestCases(sqlTestCases);
+        runTestResponse = {
+          id: attemptId,
+          executions: [
+            {
+              input: '',
+              evaluation: {
+                testcase: true,
+                score: 100,
+              },
+              run: {
+                stdout: "'Hello', 'World'",
+                stderr: null,
+                output: "'Hello', 'World'",
+                signal: null,
+                code: 0,
+              },
+              compile: null,
+              attempt_id: 'attempt-passing-123',
+              submission_id: 'submission-passing-123',
+              validation_id: null,
+              id: 'exec-passing-123',
+              created_at: '2024-03-01T12:00:00.000Z',
+              updated_at: '2024-03-01T12:00:00.000Z',
+            },
+            {
+              input: '',
+              evaluation: {
+                testcase: false,
+                score: 0,
+              },
+              run: {
+                stdout: "'Hello', 'World'",
+                stderr: "Expected: 'Goodbye', 'Everyone'",
+                output: "'Hello', 'World'",
+                signal: null,
+                code: 1,
+              },
+              compile: null,
+              attempt_id: 'attempt-failing-123',
+              submission_id: 'submission-failing-123',
+              validation_id: null,
+              id: 'exec-failing-123',
+              created_at: '2024-03-01T12:05:00.000Z',
+              updated_at: '2024-03-01T12:05:00.000Z',
+            },
+          ],
+        };
+        SQLResultsValue = {
+          resume: { ok: 1, error: 1, total: 2 },
+          listResponse: [
+            {
+              actualOutput: "'Hello', 'World'",
+              logs: sqlexecutedSuccessfullyCopyPath,
+              status: 'passed',
+            },
+            {
+              actualOutput: "'Hello', 'World'",
+              logs: "Expected: 'Goodbye', 'Everyone'\n",
+              status: 'error',
+            },
+          ],
+        };
+      });
+
+      it('should call setSqlTestCases and getSqlTestCases', () => {
+        const retrievedTestCases = service.getSqlTestCases();
+        expect(retrievedTestCases).toEqual(sqlTestCases);
+      });
+
+      describe('and publicPreview === true', () => {
+        it('should call coderunnerApiService runPublicTest$', fakeAsync(() => {
+          runTestData = {
+            code: 'SELECT value FROM test_table;',
+          };
+          const runCodeSpy = jest.spyOn(coderunnerApiService, 'runPublicTest$');
+
+          service.runTest(
+            resultId,
+            runTestData.code as string,
+            false,
+            true,
+            true
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            runTestData.code,
+            service.getSqlTestCases(),
+            ProgrammingLanguageVersioned.SQLite
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, true, false, id, 0);
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, true, false, id, 0);
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(SQLResultsValue);
+          });
+
+          flush();
+        }));
+      });
+
+      describe('and publicPreview === false and preview === true', () => {
+        it('should call coderunnerApiService runPreviewTest$', fakeAsync(() => {
+          runTestData = {
+            code: 'SELECT value FROM test_table;',
+          };
+
+          const runCodeSpy = jest.spyOn(
+            coderunnerApiService,
+            'runPreviewTest$'
+          );
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            false,
+            true,
+            false,
+            true,
+            id,
+            testResultId
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            testResultId,
+            runTestData.code,
+            service.getSqlTestCases(),
+            ProgrammingLanguageVersioned.SQLite
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, false, true, id, 0);
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, false, true, id, 0);
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(SQLResultsValue);
+          });
+
+          flush();
+        }));
+      });
+      describe('and publicPreview === false and preview === false', () => {
+        it('should call candidatureApiService sendCodeEvent$', fakeAsync(() => {
+          jest
+            .spyOn(coderunnerApiService, 'runNonPreviewTest$')
+            .mockReturnValue(of(runTestResponse));
+          runTestData = {
+            code: 'SELECT value FROM test_table;',
+          };
+          const sendEventSpy = jest.spyOn(
+            coderunnerApiService,
+            'sendCodeEvent$'
+          );
+          const event = {
+            event_type: 'ATTEMPT',
+            attempt_id: attemptId,
+            extra_payload: '',
+            question_result_id: resultId,
+            code: runTestData.code,
+            language: `${service['currentLanguage'].name}-${service['currentLanguage'].version}`,
+          };
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            false,
+            true,
+            false,
+            false,
+            id
+          );
+
+          tick();
+          expect(sendEventSpy).toHaveBeenCalledWith(event);
+        }));
+        it('should call coderunnerApiService runNonPreviewTest$', fakeAsync(() => {
+          runTestData = {
+            code: 'SELECT value FROM test_table;',
+          };
+          const runCodeSpy = jest.spyOn(
+            coderunnerApiService,
+            'runNonPreviewTest$'
+          );
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            false,
+            true,
+            false,
+            false,
+            id
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            id,
+            resultId,
+            runTestData.code,
+            service.getSqlTestCases(),
+            ProgrammingLanguageVersioned.SQLite
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, false, false, id, 0);
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(resultId, code, false, true, false, false, id, 0);
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(SQLResultsValue);
+          });
+
+          flush();
+        }));
+      });
+    });
+
+    describe('and isLAT  === true', () => {
+      let testUuidRaw: string;
+      let testUuidTransformed: string;
+      let testName: string;
+      let testData: TestResultRead;
+      let mixpanelSpy: jest.SpyInstance;
+      const mixpanelTestCasesEvent = 'Candidate ran tests in Coderunner';
+      const attemptId = '45677';
+
+      beforeEach(() => {
+        testUuidRaw = 'some-test-uuid';
+        testUuidTransformed = 'sometestuuid';
+        testName = 'coding lat entry level';
+        testData = {
+          is_preview_mode: true,
+          uuid: testUuidRaw,
+          test: { name: testName },
+        } as TestResultRead;
+        mixpanelSpy = jest.spyOn(mixpanelService, 'track');
+      });
+
+      describe('and publicPreview === true', () => {
+        beforeEach(() => {
+          runTestResponse = {
+            id: attemptId,
+            executions: [
+              {
+                input: '1\n2\n2',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: '0 1 0\n',
+                  stderr: null,
+                  output: '0 1 0\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: '1\n2\n3',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  stdout: '0 0 1\n',
+                  stderr: null,
+                  output: '0 0 1\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: 'Custom 1',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: '0 1 0\n',
+                  stderr: null,
+                  output: '0 1 0\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: 'Custom 2',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  stdout: '0 0 1\n',
+                  stderr: null,
+                  output: '0 0 1\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+            ],
+          };
+          LATResultsValue = {
+            resume: { ok: 2, error: 2, total: 4 },
+            listResponse: [
+              {
+                actualOutput: '0 1 0\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: '0 0 1\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'error',
+              },
+              {
+                actualOutput: '0 1 0\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: '0 0 1\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'error',
+              },
+            ],
+          };
+        });
+        it('should call libCodingTestService getValidTestCases', () => {
+          service.runTest(resultId, code, true, false, true);
+
+          expect(
+            jest.spyOn(libCodingTestService, 'getValidTestCases')
+          ).toHaveBeenCalled();
+        });
+        it('should call coderunnerApiService runPublicTest$', fakeAsync(() => {
+          const runTestData = {
+            code: "def countIntegers(n, val, arr):\n    smaller = sum(1 for num in arr if num < val)\n    equal = sum(1 for num in arr if num == val)\n    greater = sum(1 for num in arr if num > val)\n    return [smaller, equal, greater]\n\nn = int(input())\nval = int(input())\narr = list(map(int, input().split()))\n\nresult = countIntegers(n, val, arr)\nprint(' '.join(map(str, result)))\n",
+            testcases: [
+              {
+                input: '1\n2\n2',
+                solution: '0 1 0',
+              },
+              {
+                input: '1\n2\n3',
+                solution: '0 1 1',
+              },
+              {
+                input: 'Custom 1',
+                solution: '0 1 0',
+              },
+              {
+                input: 'Custom 2',
+                solution: '0 1 1',
+              },
+            ],
+          };
+          const runCodeSpy = jest.spyOn(coderunnerApiService, 'runPublicTest$');
+
+          service.runTest(
+            resultId,
+            runTestData.code as string,
+            true,
+            false,
+            true
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            runTestData.code,
+            runTestData.testcases,
+            LATlanguage + '-' + LATversion
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(resultId, code, true, false, true);
+
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(resultId, code, true, false, true);
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(LATResultsValue);
+          });
+
+          flush();
+        }));
+      });
+
+      describe('and publicPreview === false and preview === true', () => {
+        beforeEach(() => {
+          runTestResponse = {
+            executions: [
+              {
+                input: '1\n2\n2',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: '0 1 0\n',
+                  stderr: null,
+                  output: '0 1 0\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: '1\n2\n3',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  stdout: '0 0 1\n',
+                  stderr: null,
+                  output: '0 0 1\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: 'Custom 1',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: '0 1 0\n',
+                  stderr: null,
+                  output: '0 1 0\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+              {
+                input: 'Custom 2',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  stdout: '0 0 1\n',
+                  stderr: null,
+                  output: '0 0 1\n',
+                  signal: null,
+                  code: null,
+                },
+                compile: null,
+              },
+            ],
+          };
+          LATResultsValue = {
+            resume: { ok: 2, error: 2, total: 4 },
+            listResponse: [
+              {
+                actualOutput: '0 1 0\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: '0 0 1\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'error',
+              },
+              {
+                actualOutput: '0 1 0\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: '0 0 1\n',
+                logs: executedSuccessfullyCopyPath,
+                status: 'error',
+              },
+            ],
+          };
+        });
+        it('should call libCodingTestService getValidTestCases', () => {
+          service.runTest(resultId, code, true, false, false, true, id);
+
+          expect(
+            jest.spyOn(libCodingTestService, 'getValidTestCases')
+          ).toHaveBeenCalled();
+        });
+
+        it('should track mixpanel event with custom test cases data', fakeAsync(() => {
+          const expectedMixpanelEvent = {
+            coding_test_uuid: testUuidTransformed,
+            coding_test_name: testName,
+            coderunner_test_instance: 'practice question',
+            custom_testcases_passed: 1,
+            custom_testcases_failed: 1,
+            custom_testcases_empty: 2,
+            example_testcases_passed: 1,
+            example_testcases_failed: 1,
+            coderunner_response_time: expect.any(Number),
+          };
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            true,
+            id,
+            0,
+            testData
+          );
+          tick();
+
+          expect(mixpanelSpy).toHaveBeenCalledWith(
+            mixpanelTestCasesEvent,
+            expectedMixpanelEvent
+          );
+          flush();
+        }));
+
+        it('should call coderunnerApiService runPreviewTest$', fakeAsync(() => {
+          const runTestData = {
+            code: "def countIntegers(n, val, arr):\n    smaller = sum(1 for num in arr if num < val)\n    equal = sum(1 for num in arr if num == val)\n    greater = sum(1 for num in arr if num > val)\n    return [smaller, equal, greater]\n\nn = int(input())\nval = int(input())\narr = list(map(int, input().split()))\n\nresult = countIntegers(n, val, arr)\nprint(' '.join(map(str, result)))\n",
+            testcases: [
+              {
+                input: '1\n2\n2',
+                solution: '0 1 0',
+              },
+              {
+                input: '1\n2\n3',
+                solution: '0 1 1',
+              },
+              {
+                input: 'Custom 1',
+                solution: '0 1 0',
+              },
+              {
+                input: 'Custom 2',
+                solution: '0 1 1',
+              },
+            ],
+          };
+          const runCodeSpy = jest.spyOn(
+            coderunnerApiService,
+            'runPreviewTest$'
+          );
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            true,
+            false,
+            false,
+            true,
+            id,
+            testResultId,
+            testData
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            testResultId,
+            runTestData.code,
+            runTestData.testcases,
+            LATlanguage + '-' + LATversion
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            true,
+            id,
+            0,
+            testData
+          );
+
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            true,
+            id,
+            0,
+            testData
+          );
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(LATResultsValue);
+          });
+
+          flush();
+        }));
+      });
+
+      describe('and publicPreview === false and preview === false', () => {
+        beforeEach(() => {
+          testData = { ...testData, is_preview_mode: false };
+          runTestResponse = {
+            executions: [
+              {
+                input: '1\n2\n2',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  code: null,
+                  output: null,
+                  signal: 'SIGKILL',
+                  stderr: null,
+                  stdout: null,
+                },
+                compile: {
+                  stderr: null,
+                },
+              },
+              {
+                input: '1\n2\n3',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: '',
+                  stderr: null,
+                  output: '',
+                  signal: null,
+                  code: null,
+                },
+                compile: {
+                  stderr: null,
+                },
+              },
+              {
+                input: 'Custom 1',
+                evaluation: {
+                  score: 0,
+                  testcase: true,
+                },
+                run: {
+                  stdout: null,
+                  stderr: null,
+                  output: null,
+                  signal: null,
+                  code: null,
+                },
+                compile: {
+                  stderr: null,
+                },
+              },
+              {
+                input: 'Custom 2',
+                evaluation: {
+                  score: 0,
+                  testcase: false,
+                },
+                run: {
+                  stdout: null,
+                  stderr: 'something went wrong',
+                  output: null,
+                  signal: null,
+                  code: null,
+                },
+                compile: {
+                  stderr: 'something went wrong',
+                },
+              },
+            ],
+          };
+          LATResultsValue = {
+            resume: { ok: 2, error: 2, total: 4 },
+            listResponse: [
+              {
+                actualOutput: noResponseOutputCopyPath,
+                logs: timeoutErrorCopyPath,
+                status: 'error',
+              },
+              {
+                actualOutput: noneOutputCopyPath,
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: noneOutputCopyPath,
+                logs: executedSuccessfullyCopyPath,
+                status: 'passed',
+              },
+              {
+                actualOutput: noResponseOutputCopyPath,
+                logs: 'something went wrong',
+                status: 'error',
+              },
+            ],
+          };
+        });
+        it('should call libCodingTestService getValidTestCases', () => {
+          service.runTest(resultId, code, true, false, false, false, id);
+
+          expect(
+            jest.spyOn(libCodingTestService, 'getValidTestCases')
+          ).toHaveBeenCalled();
+        });
+
+        it('should track mixpanel event with custom test cases data', fakeAsync(() => {
+          const expectedMixpanelEvent = {
+            coding_test_uuid: testUuidTransformed,
+            coding_test_name: testName,
+            coderunner_test_instance: 'real test',
+            custom_testcases_passed: 1,
+            custom_testcases_failed: 1,
+            custom_testcases_empty: 2,
+            example_testcases_failed: 1,
+            example_testcases_passed: 1,
+            coderunner_response_time: expect.any(Number),
+          };
+
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            false,
+            id,
+            0,
+            testData
+          );
+          tick();
+
+          expect(mixpanelSpy).toHaveBeenCalledWith(
+            mixpanelTestCasesEvent,
+            expectedMixpanelEvent
+          );
+          flush();
+        }));
+
+        it('should call candidatureApiService sendCodeEvent$', fakeAsync(() => {
+          jest
+            .spyOn(coderunnerApiService, 'runNonPreviewTest$')
+            .mockReturnValue(of(runTestResponse));
+          const runTestData = {
+            code: 'SELECT value FROM test_table;',
+          };
+          const sendEventSpy = jest.spyOn(
+            coderunnerApiService,
+            'sendCodeEvent$'
+          );
+          const event = {
+            event_type: 'ATTEMPT',
+            attempt_id: '',
+            extra_payload: '',
+            question_result_id: resultId,
+            code: runTestData.code,
+            language: `${service['currentLanguage'].name}-${service['currentLanguage'].version}`,
+          };
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            true,
+            false,
+            false,
+            false,
+            id,
+            0,
+            testData
+          );
+
+          tick();
+          expect(sendEventSpy).toHaveBeenCalledWith(event);
+        }));
+
+        it('should call coderunnerApiService runNonPreviewTest$', fakeAsync(() => {
+          const runTestData = {
+            code: "def countIntegers(n, val, arr):\n    smaller = sum(1 for num in arr if num < val)\n    equal = sum(1 for num in arr if num == val)\n    greater = sum(1 for num in arr if num > val)\n    return [smaller, equal, greater]\n\nn = int(input())\nval = int(input())\narr = list(map(int, input().split()))\n\nresult = countIntegers(n, val, arr)\nprint(' '.join(map(str, result)))\n",
+            testcases: [
+              {
+                input: '1\n2\n2',
+                solution: '0 1 0',
+              },
+              {
+                input: '1\n2\n3',
+                solution: '0 1 1',
+              },
+              {
+                input: 'Custom 1',
+                solution: '0 1 0',
+              },
+              {
+                input: 'Custom 2',
+                solution: '0 1 1',
+              },
+            ],
+          };
+          const runCodeSpy = jest.spyOn(
+            coderunnerApiService,
+            'runNonPreviewTest$'
+          );
+
+          service.runTest(
+            resultId,
+            runTestData.code,
+            true,
+            false,
+            false,
+            false,
+            id,
+            0,
+            testData
+          );
+
+          tick();
+          expect(runCodeSpy).toHaveBeenCalledWith(
+            id,
+            resultId,
+            runTestData.code,
+            runTestData.testcases,
+            LATlanguage + '-' + LATversion
+          );
+        }));
+        it('should emit isLoading false', fakeAsync(() => {
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            false,
+            id,
+            0,
+            testData
+          );
+
+          tick();
+          expect(service.isTestResultsLoading()).toBeFalsy();
+
+          flush();
+        }));
+        it('should emit returned value to codingTestResults$', fakeAsync(() => {
+          service.runTest(
+            resultId,
+            code,
+            true,
+            false,
+            false,
+            false,
+            id,
+            0,
+            testData
+          );
+          tick();
+
+          service.codingTestResults$.subscribe((val) => {
+            expect(val).toEqual(LATResultsValue);
+          });
+
+          flush();
+        }));
+      });
+    });
+  });
+
+  describe('when reset  run test state summary is called', () => {
+    beforeEach(() => {
+      runTestResponse = {
+        executions: [
+          {
+            input: '1\n2\n2',
+            evaluation: {
+              score: 0,
+              testcase: false,
+            },
+            run: {
+              code: null,
+              output: null,
+              signal: 'SIGKILL',
+              stderr: null,
+              stdout: null,
+            },
+            compile: {
+              stderr: null,
+            },
+          },
+          {
+            input: '1\n2\n3',
+            evaluation: {
+              score: 0,
+              testcase: true,
+            },
+            run: {
+              stdout: '',
+              stderr: null,
+              output: '',
+              signal: null,
+              code: null,
+            },
+            compile: {
+              stderr: null,
+            },
+          },
+          {
+            input: 'Custom 1',
+            evaluation: {
+              score: 0,
+              testcase: true,
+            },
+            run: {
+              stdout: null,
+              stderr: null,
+              output: null,
+              signal: null,
+              code: null,
+            },
+            compile: {
+              stderr: null,
+            },
+          },
+          {
+            input: 'Custom 2',
+            evaluation: {
+              score: 0,
+              testcase: false,
+            },
+            run: {
+              stdout: null,
+              stderr: 'something went wrong',
+              output: null,
+              signal: null,
+              code: null,
+            },
+            compile: {
+              stderr: 'something went wrong',
+            },
+          },
+        ],
+      };
+    });
+
+    it('should set default summary and publish it', fakeAsync(() => {
+      const defaultSummary = {
+        listResponse: [],
+        resume: {
+          ok: 0,
+          error: 0,
+          total: 0,
+        },
+      };
+
+      service.runTest(resultId, code, true, false, true);
+
+      tick();
+      service.resetRunTestSummary();
+
+      service.codingTestResults$.subscribe((summary) => {
+        expect(summary).toEqual(defaultSummary);
+      });
+
+      flush();
+    }));
+  });
+
+  describe('when track config changed is called', () => {
+    let mixpanelSpy: jest.SpyInstance;
+    let props: {
+      coderunner_setting: string;
+      coderunner_setting_new_value: string;
+      coderunner_setting_instance: string;
+    };
+    const mixpanelSettingsEvent = 'Changed Coderunner setting';
+
+    beforeEach(() => {
+      mixpanelSpy = jest.spyOn(mixpanelService, 'track');
+    });
+
+    describe('and when is practice question, theme is changed', () => {
+      it('should call mixpanel with practice question, theme, themeValue', fakeAsync(() => {
+        const setting = 'Color theme';
+        const value = 'dark';
+        libCodingTestServiceMock.configFieldChanged$ = scheduled(
+          of({ [setting]: `theme-${value}` }),
+          asyncScheduler
+        ) as unknown as Observable<null>;
+        props = {
+          coderunner_setting: setting,
+          coderunner_setting_new_value: value,
+          coderunner_setting_instance: 'practice question',
+        };
+        service.trackConfigChanged(true);
+
+        tick();
+
+        expect(mixpanelSpy).toBeCalledWith(mixpanelSettingsEvent, props);
+      }));
+    });
+
+    describe('and when is NOT practice question, fullscreen is changed', () => {
+      it('should call mixpanel with real test, full screen, value', fakeAsync(() => {
+        const setting = 'Full screen';
+        libCodingTestServiceMock.configFieldChanged$ = scheduled(
+          of({ [setting]: true }),
+          asyncScheduler
+        ) as unknown as Observable<null>;
+        props = {
+          coderunner_setting: setting,
+          coderunner_setting_new_value: 'ON',
+          coderunner_setting_instance: 'real test',
+        };
+        service.trackConfigChanged();
+
+        tick();
+
+        expect(mixpanelSpy).toBeCalledWith(mixpanelSettingsEvent, props);
+      }));
+    });
+
+    describe('and when is practice question, font size is changed', () => {
+      it('should call mixpanel with practice question, font, font size', fakeAsync(() => {
+        const setting = 'Font size';
+        libCodingTestServiceMock.configFieldChanged$ = scheduled(
+          of({ [setting]: 12 }),
+          asyncScheduler
+        ) as unknown as Observable<null>;
+        props = {
+          coderunner_setting: setting,
+          coderunner_setting_new_value: '12',
+          coderunner_setting_instance: 'practice question',
+        };
+        service.trackConfigChanged(true);
+
+        tick();
+
+        expect(mixpanelSpy).toBeCalledWith(mixpanelSettingsEvent, props);
+      }));
+    });
+  });
+});