@testgorilla/tgo-coding-test 0.0.1

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

@@ -0,0 +1,843 @@
+import { Injectable, signal } from '@angular/core';
+import { translate } from '@ngneat/transloco';
+import {
+  ApplicationTheme,
+  ConfirmDialogComponent,
+  DialogService,
+  SnackbarService,
+} from '@testgorilla/tgo-ui';
+import {
+  MixpanelService,
+  TestResultRead,
+} from '@testgorilla/tgo-test-shared';
+import {
+  CustomTestCase,
+  ExampleTestCase,
+  TestCaseDeletionAction,
+  TestCaseDeletionData,
+} from '../../models/test-cases';
+import { LibCodingTestService, ResetCodeAction } from '../lib-coding-test.service';
+import { CodeEditorLanguages } from '../../components/code-editor/helpers/code-editor-helper.model';
+import {
+  BehaviorSubject,
+  Observable,
+  Subject,
+  filter,
+  of,
+  takeUntil,
+  throwError,
+} from 'rxjs';
+import { catchError, map, switchMap, take, tap } from 'rxjs/operators';
+import { CodeEvent, CodeEventResponse } from '../../models/code-event';
+import {
+  CodeRunnerTestCaseExecutionOutputModel,
+  CoderunnerAttemptModel,
+  CoderunnerTestCaseExecutionModel,
+  CodingTestsResultsModel,
+  TIMEOUT_SIGNAL,
+} from '../../models/coderunner-execution-results';
+import { MixpanelEvents } from '../../models/mixpanel-events';
+import {
+  ProgrammingLanguage,
+  ProgrammingLanguageVersioned,
+} from '../../models/programming-language';
+import {
+  GroupedTestCasesResult,
+  LATFormattedTestCases,
+  SqlTestCase,
+  Testcase,
+} from '../../models/test-cases';
+import { ROOT_TRANSLATIONS_SCOPE } from '../../models/translations';
+import { CoderunnerApiService } from './coderunner-api.service';
+
+interface CustomError {
+  detail?: string;
+}
+
+@Injectable()
+export class CodingTestService {
+  readonly translationContext = `${ROOT_TRANSLATIONS_SCOPE}.CODING_LIB.`;
+
+  private codingTestResults: CodingTestsResultsModel = {
+    listResponse: [],
+    resume: {
+      ok: 0,
+      error: 0,
+      total: 0,
+    },
+  };
+  private currentLanguage!: ProgrammingLanguage;
+  private codingTestResutsSubj$ = new BehaviorSubject(this.codingTestResults);
+  codingTestResults$ = this.codingTestResutsSubj$.asObservable();
+
+  isTestResultsLoading = signal<boolean>(false);
+
+  private unsubscribe$ = new Subject<void>();
+
+  private sqlTestCases!: SqlTestCase[];
+  private isSQLTest = false;
+
+  constructor(
+    private coderunnerApiService: CoderunnerApiService,
+    private libCodingTestService: LibCodingTestService,
+    private mixpanel: MixpanelService,
+    private snackBar: SnackbarService,
+    private dialog: DialogService
+  ) {}
+
+  private getBaseExampleTestCase = (id: number, index: number) => ({
+    id: id ?? 0,
+    name: `Example ${index + 1}`,
+    preloaded: true,
+  });
+
+  transformToExampleLATtestCase = (
+    testcase: Testcase,
+    index: number
+  ): ExampleTestCase => ({
+    ...this.getBaseExampleTestCase(testcase.id!, index),
+    expectedOutput: testcase.solution ?? '',
+    input: testcase.input,
+  });
+
+  transformToExampleSQLTestCase = (
+    testcase: SqlTestCase,
+    index: number
+  ): ExampleTestCase => ({
+    ...this.getBaseExampleTestCase(testcase.id!, index),
+    expectedOutput: testcase.result ?? '',
+  });
+
+  setSqlTestCases(sqlTestCases: SqlTestCase[]) {
+    this.sqlTestCases = sqlTestCases;
+  }
+
+  getSqlTestCases(): SqlTestCase[] {
+    return this.sqlTestCases;
+  }
+
+  handleResetCodeModal(applicationTheme: ApplicationTheme, companyColor: string): void {
+    const modalTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.RESET_CODE.`;
+    const modalData = {
+      confirmButtonText: translate(`${modalTranslationContext}SUBMIT`),
+      title: translate(`${modalTranslationContext}TITLE`),
+      message: translate(`${modalTranslationContext}MESSAGE`),
+      color: companyColor,
+    };
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      applicationTheme,
+      size: 'small',
+      extraData: modalData,
+    });
+
+    dialogRef
+      .afterClosed()
+      .pipe(filter(Boolean), take(1))
+      .subscribe(() => {
+        this.libCodingTestService.confirmReset();
+      });
+  }
+
+  listenDeleteCustomTestCases(): Observable<TestCaseDeletionData> {
+    return this.libCodingTestService.testCaseDeletion$.pipe(
+      filter(({ action }) => action === TestCaseDeletionAction.Try)
+    );
+  }
+
+  handleDeleteTestCaseModal(
+    index: number,
+    applicationTheme: ApplicationTheme,
+    companyColor: string
+  ): void {
+    const deleteTestCaseTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.DELETE_TEST_CASE.`;
+    const modalData = {
+      title: translate(`${deleteTestCaseTranslationContext}TITLE`),
+      message: translate(`${deleteTestCaseTranslationContext}MESSAGE`),
+      confirmButtonText: translate(`${deleteTestCaseTranslationContext}SUBMIT`),
+      color: companyColor,
+    };
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      applicationTheme,
+      size: 'small',
+      extraData: modalData,
+    });
+
+    dialogRef
+      .afterClosed()
+      .pipe(filter(Boolean), take(1))
+      .subscribe(() => {
+        this.libCodingTestService.confirmTestCaseDeletion(index);
+      });
+  }
+
+  handleLanguageChangeModal(
+    questionResultId: number,
+    selectedLanguage?: ProgrammingLanguage,
+    applicationTheme: ApplicationTheme = 'light',
+    companyColor?: string,
+  ): void {
+    const modalLangChangeTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.LANGUAGE_CHANGE.`;
+    const modalData = {
+      confirmButtonText: translate(
+        `${modalLangChangeTranslationContext}SUBMIT`
+      ),
+      title: translate(`${modalLangChangeTranslationContext}TITLE`),
+      message: translate(`${modalLangChangeTranslationContext}MESSAGE`),
+      ...(companyColor && { color: companyColor }),
+    };
+
+    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+      applicationTheme,
+      size: 'small',
+      extraData: modalData,
+    });
+
+    dialogRef
+      .afterClosed()
+      .pipe(take(1))
+      .subscribe((result) => {
+        if (result) {
+          this.libCodingTestService.confirmLanguageChange();
+          if (selectedLanguage) {
+            this.setCurrentLanguageLAT(selectedLanguage);
+            this.sendLanguageChangeEvent$(questionResultId);
+          }
+        } else {
+          this.libCodingTestService.cancelLanguageChange();
+        }
+      });
+  }
+
+  setCurrentLanguageLAT(language: ProgrammingLanguage): void {
+    this.currentLanguage = language;
+  }
+
+  listenCodingTestChanges(): Observable<ResetCodeAction> {
+    return this.libCodingTestService.codeReset$.pipe(
+      filter((val) => val === ResetCodeAction.Try)
+    );
+  }
+
+  runTest(
+    resultId: number,
+    code: string,
+    isLAT = true,
+    isSQL = false,
+    // todo: remove from everywhere or comment temporarily?
+    publicPreview = false,
+    preview = false,
+    id = 0,
+    testResultId = 0,
+    testData?: TestResultRead
+  ): void {
+    this.preRunTests();
+    if (isSQL) {
+      this.getSQLrequest(
+        resultId,
+        testResultId,
+        code,
+        id,
+        publicPreview,
+        preview
+      );
+    } else if (isLAT) {
+      const testCases: (ExampleTestCase | CustomTestCase)[] =
+        this.libCodingTestService.getValidTestCases();
+      const testCasesFormatted = testCases.map((testCase) => ({
+        input: testCase.input,
+        solution: testCase.expectedOutput,
+      })) as LATFormattedTestCases[];
+      this.libCodingTestService.currentLanguage$
+        .pipe(take(1))
+        .subscribe((language) => {
+          const runReq$ = this.getLATrequest(
+            id,
+            resultId,
+            testResultId,
+            code,
+            testCasesFormatted as LATFormattedTestCases[],
+            language,
+            publicPreview,
+            preview
+          );
+          this.runLAT(
+            runReq$,
+            publicPreview,
+            preview,
+            testData || ({} as TestResultRead),
+            testCases,
+            code,
+            resultId
+          );
+        });
+    }
+  }
+
+  sendCopypasteEvent$(
+    code: string,
+    copiedText: string,
+    questionResultId: number
+  ): Observable<CodeEventResponse> {
+    const event: CodeEvent = this.getBaseEvent({
+      code,
+      event_type: 'COPYPASTE',
+      extra_payload: copiedText,
+      question_result_id: questionResultId,
+    });
+
+    return this.coderunnerApiService.sendCodeEvent$(event);
+  }
+
+  sendAutosaveEvent$(
+    code: string,
+    questionResultId: number
+  ): Observable<CodeEventResponse> {
+    const event: CodeEvent = this.getBaseEvent({
+      code,
+      event_type: 'AUTOSAVE',
+      question_result_id: questionResultId,
+    });
+
+    return this.coderunnerApiService
+      .sendCodeEvent$(event)
+      .pipe(catchError((err) => of(err)));
+  }
+
+  private sendLanguageChangeEvent$(questionResultId: number): void {
+    const event: CodeEvent = this.getBaseEvent({
+      event_type: 'SWITCH',
+      question_result_id: questionResultId,
+    });
+
+    this.coderunnerApiService.sendCodeEvent$(event).pipe(take(1)).subscribe();
+  }
+
+  private getBaseEvent(event: Partial<CodeEvent>): CodeEvent {
+    let language = '';
+
+    if (this.isSQLTest) {
+      language = ProgrammingLanguageVersioned.SQLite;
+    } else {
+      const { name, version } = this.currentLanguage;
+      language = `${name}-${version}`;
+    }
+
+    const baseEvent: Partial<CodeEvent> = {
+      code: '',
+      extra_payload: '',
+      attempt_id: null,
+      language,
+    };
+
+    return { ...baseEvent, ...event } as CodeEvent;
+  }
+
+  private sendCodeEvent$(
+    attemptId: string,
+    questionResultId: number,
+    code: string
+  ): Observable<CodeEventResponse> {
+    const event: CodeEvent = this.getBaseEvent({
+      code,
+      attempt_id: attemptId,
+      event_type: 'ATTEMPT',
+      question_result_id: questionResultId,
+    });
+
+    return this.coderunnerApiService.sendCodeEvent$(event);
+  }
+
+  private countTestResults(
+    executions: CoderunnerTestCaseExecutionModel[] | undefined
+  ): {
+    passed: number;
+    error: number;
+    total: number;
+  } {
+    if (executions) {
+      return executions.reduce(
+        (acc, response) => {
+          if (response.evaluation.testcase) {
+            acc.passed++;
+          } else {
+            acc.error++;
+          }
+          acc.total++;
+          return acc;
+        },
+        { passed: 0, error: 0, total: 0 }
+      );
+    }
+    return { passed: 0, error: 0, total: 0 };
+  }
+
+  private handleTestCasesResult(
+    testCasesResultObject: CodingTestsResultsModel
+  ): void {
+    this.codingTestResults = testCasesResultObject;
+    this.publishTestResults();
+    this.isTestResultsLoading.set(false);
+  }
+
+  private getSQLrequest(
+    resultId: number,
+    testResultId: number,
+    code: string,
+    id: number,
+    publicPreview: boolean,
+    preview: boolean
+  ): void {
+    const testCases: SqlTestCase[] = this.getSqlTestCases();
+    let runReq$: Observable<CoderunnerAttemptModel>;
+    if (publicPreview) {
+      runReq$ = this.coderunnerApiService.runPublicTest$(
+        code,
+        testCases,
+        ProgrammingLanguageVersioned.SQLite
+      );
+    } else if (preview) {
+      runReq$ = this.coderunnerApiService.runPreviewTest$(
+        testResultId,
+        code,
+        testCases,
+        ProgrammingLanguageVersioned.SQLite
+      );
+    } else {
+      runReq$ = this.coderunnerApiService.runNonPreviewTest$(
+        id,
+        resultId,
+        code,
+        testCases,
+        ProgrammingLanguageVersioned.SQLite
+      );
+    }
+    this.runSql(runReq$, testCases, resultId, !publicPreview && !preview, code);
+  }
+
+  private runSql(
+    runReq$: Observable<CoderunnerAttemptModel>,
+    testCases: SqlTestCase[],
+    questionResultId: number,
+    isActualQuestion: boolean,
+    code: string
+  ) {
+    let attemptId = '';
+
+    runReq$
+      .pipe(
+        catchError((err) => {
+          this.finalizeReq(err);
+          return throwError(() => err);
+        }),
+        tap((res) => this.finalizeReq(res as CustomError)),
+        tap(({ id }) => (attemptId = id ?? '')),
+        switchMap((responseArray: CoderunnerAttemptModel) =>
+          of(responseArray.executions).pipe(
+            map((executions) => this.countTestResults(executions)),
+            map((countResult) => {
+              const sqlExecutedSuccessfullyCopy = translate(
+                `${this.translationContext}TEST_RESULTS.TEST_CASES.SQL_EXECUTED_SUCCESSFULLY`
+              );
+              const noOutputCopies = this.getNoOutputCopies();
+
+              return {
+                resume: {
+                  ok: countResult.passed,
+                  error: countResult.error,
+                  total: countResult.total,
+                },
+                listResponse: responseArray.executions?.map(
+                  ({ run, evaluation }: CoderunnerTestCaseExecutionModel) => ({
+                    actualOutput: run.stdout
+                      ? run.stdout
+                      : run.stderr || run.signal === TIMEOUT_SIGNAL
+                      ? noOutputCopies['noResponse']
+                      : noOutputCopies['noOutput'],
+                    logs: this.getCoderunnerLogs(
+                      run,
+                      TIMEOUT_SIGNAL,
+                      noOutputCopies['timeoutError'],
+                      sqlExecutedSuccessfullyCopy
+                    ),
+                    status: evaluation.testcase ? 'passed' : 'error',
+                  })
+                ),
+              } as CodingTestsResultsModel;
+            }),
+            tap((testCasesResultObject) =>
+              this.handleTestCasesResult(testCasesResultObject)
+            )
+          )
+        ),
+        switchMap(() =>
+          this.getSendCodeEventStream$(
+            isActualQuestion,
+            attemptId,
+            questionResultId,
+            code
+          )
+        )
+      )
+      .subscribe();
+  }
+
+  private getLATrequest(
+    id: number,
+    resultId: number,
+    testResultId: number,
+    code: string,
+    testCasesFormatted: LATFormattedTestCases[],
+    language: CodeEditorLanguages,
+    publicPreview: boolean,
+    preview: boolean
+  ): Observable<CoderunnerAttemptModel> {
+    if (publicPreview) {
+      return this.coderunnerApiService.runPublicTest$(
+        code,
+        testCasesFormatted,
+        `${language}-${this.libCodingTestService.getVersion()}`
+      );
+    } else if (preview) {
+      return this.coderunnerApiService.runPreviewTest$(
+        testResultId,
+        code,
+        testCasesFormatted,
+        `${language}-${this.libCodingTestService.getVersion()}`
+      );
+    } else {
+      return this.coderunnerApiService.runNonPreviewTest$(
+        id,
+        resultId,
+        code,
+        testCasesFormatted,
+        `${language}-${this.libCodingTestService.getVersion()}`
+      );
+    }
+  }
+
+  setIsSQLTest(isSQL: boolean): void {
+    this.isSQLTest = isSQL;
+  }
+
+  private runLAT(
+    runCodeRequest$: Observable<CoderunnerAttemptModel>,
+    isPublicPreviewLAT: boolean,
+    isPractice = false,
+    testData: TestResultRead,
+    testCases: ExampleTestCase[] | CustomTestCase[],
+    code: string,
+    questionResultId: number
+  ): void {
+    const pistonRegex = /\/piston\/[^/ ]+(\/[^/ ]+)*/g;
+    const reqStartTime = performance.now();
+    let reqEndTime: number;
+    let attemptId = '';
+
+    runCodeRequest$
+      .pipe(
+        catchError((err) => {
+          this.finalizeReq(err);
+          return throwError(() => err);
+        }),
+        tap((res) => this.finalizeReq(res as CustomError)),
+        tap(() => (reqEndTime = performance.now())),
+        tap(({ id }) => (attemptId = id ?? '')),
+        switchMap((responseArray: CoderunnerAttemptModel) =>
+          of(responseArray.executions).pipe(
+            map((executions) => (executions ? executions : [])),
+            map((executions: CoderunnerTestCaseExecutionModel[]) =>
+              executions.map((x) => {
+                if (x.run.stderr) {
+                  x.run.stderr = x.run.stderr.replace(pistonRegex, '');
+                }
+                if (x.run.stdout) {
+                  x.run.stdout = x.run.stdout.replace(pistonRegex, '');
+                }
+                return x;
+              })
+            ),
+            map((executions) => this.countTestResults(executions)),
+            map((countResult) => {
+              if (!isPublicPreviewLAT) {
+                const responseTime = Math.round(reqEndTime - reqStartTime);
+                this.trackTestcasesRun(
+                  testData,
+                  countResult,
+                  responseArray.executions || [],
+                  responseTime,
+                  testCases
+                );
+              }
+              const noOutputCopies = this.getNoOutputCopies();
+              const executedSuccessfullyCopy = translate(
+                `${this.translationContext}TEST_RESULTS.TEST_CASES.EXECUTED_SUCCESSFULLY`
+              );
+
+              return {
+                resume: {
+                  ok: countResult.passed,
+                  error: countResult.error,
+                  total: countResult.total,
+                },
+                listResponse: responseArray.executions?.map(
+                  ({
+                    run,
+                    evaluation,
+                    compile,
+                  }: CoderunnerTestCaseExecutionModel) => ({
+                    actualOutput: run.stdout
+                      ? run.stdout
+                      : run.stderr || run.signal === TIMEOUT_SIGNAL
+                      ? noOutputCopies['noResponse']
+                      : noOutputCopies['noOutput'],
+                    logs: this.getCoderunnerLogs(
+                      run,
+                      TIMEOUT_SIGNAL,
+                      noOutputCopies['timeoutError'],
+                      executedSuccessfullyCopy,
+                      compile
+                    ),
+                    status: evaluation.testcase ? 'passed' : 'error',
+                  })
+                ),
+              } as CodingTestsResultsModel;
+            }),
+            tap((testCasesResultObject) =>
+              this.handleTestCasesResult(testCasesResultObject)
+            )
+          )
+        ),
+        switchMap(() =>
+          this.getSendCodeEventStream$(
+            !isPractice && !isPublicPreviewLAT,
+            attemptId,
+            questionResultId,
+            code
+          )
+        )
+      )
+      .subscribe();
+  }
+
+  private finalizeReq(err: CustomError): void {
+    this.isTestResultsLoading.set(false);
+    if (err.detail) {
+      this.snackBar.error(err.detail);
+    }
+  }
+
+  private getNoOutputCopies(): { [key: string]: string } {
+    return {
+      noResponse: translate(
+        `${this.translationContext}TEST_RESULTS.TEST_CASES.NO_RESPONSE`
+      ),
+      noOutput: translate(
+        `${this.translationContext}TEST_RESULTS.TEST_CASES.NONE`
+      ),
+      timeoutError: translate(
+        `${this.translationContext}TEST_RESULTS.TEST_CASES.TIMEOUT_ERROR`
+      ),
+    };
+  }
+
+  private getSendCodeEventStream$(
+    isActualQuestion: boolean,
+    attemptId: string,
+    questionResultId: number,
+    code: string
+  ): Observable<CodeEventResponse> {
+    if (isActualQuestion) {
+      return this.sendCodeEvent$(attemptId, questionResultId, code);
+    } else {
+      return of({} as CodeEventResponse);
+    }
+  }
+
+  // todo: check if we need this anymore due to MFE providers specificity
+  unsubscribeAll(): void {
+    this.unsubscribe$.next();
+    this.unsubscribe$.complete();
+  }
+
+  resetRunTestSummary(): void {
+    this.codingTestResults = {
+      listResponse: [],
+      resume: {
+        ok: 0,
+        error: 0,
+        total: 0,
+      },
+    };
+
+    this.publishTestResults();
+  }
+
+  trackConfigChanged(isPracticeQuestion = false): void {
+    this.libCodingTestService.configFieldChanged$
+      .pipe(takeUntil(this.unsubscribe$))
+      .subscribe((config) => {
+        const { settingInstance, changedKey, newValueString } =
+          this.getMixpanelSettingsData(isPracticeQuestion, config);
+
+        this.mixpanel.track(MixpanelEvents.ChangedSettings, {
+          coderunner_setting: changedKey,
+          coderunner_setting_new_value: newValueString,
+          coderunner_setting_instance: settingInstance,
+        });
+      });
+  }
+
+  private getCoderunnerLogs(
+    run: CodeRunnerTestCaseExecutionOutputModel,
+    TIMEOUT_SIGNAL: string,
+    timeoutErrorCopy: string,
+    executedSuccessfullyCopy: string,
+    compile?: CodeRunnerTestCaseExecutionOutputModel,
+    isSQL?: boolean
+  ): string {
+    if (isSQL) {
+      return run?.stderr === TIMEOUT_SIGNAL
+        ? run.stderr
+        : executedSuccessfullyCopy;
+    } else if (run?.stderr) {
+      return run.stderr === compile?.stderr
+        ? run.stderr
+        : `${run.stderr}\n${compile?.stderr || ''}`;
+    } else if (run.signal === TIMEOUT_SIGNAL) {
+      return timeoutErrorCopy;
+    }
+    return executedSuccessfullyCopy;
+  }
+
+  private trackTestcasesRun(
+    testData: TestResultRead,
+    countResult: { [key: string]: number },
+    testCasesExecutions: CoderunnerTestCaseExecutionModel[],
+    responseTime: number,
+    testCases: ExampleTestCase[] | CustomTestCase[]
+  ): void {
+    const {
+      instance,
+      customPassed,
+      customFailed,
+      examplePassed,
+      exampleFailed,
+      customEmpty,
+      testUuid,
+      testName,
+    } = this.getMixpanelTestCasesData(
+      testData,
+      countResult,
+      testCasesExecutions,
+      testCases
+    );
+
+    this.mixpanel.track('Candidate ran tests in Coderunner', {
+      coding_test_uuid: testUuid,
+      coding_test_name: testName,
+      coderunner_test_instance: instance,
+      custom_testcases_passed: customPassed,
+      custom_testcases_failed: customFailed,
+      custom_testcases_empty: customEmpty,
+      example_testcases_passed: examplePassed,
+      example_testcases_failed: exampleFailed,
+      coderunner_response_time: responseTime,
+    });
+  }
+
+  private preRunTests() {
+    this.isTestResultsLoading.set(true);
+    this.resetRunTestSummary();
+  }
+
+  private getMixpanelTestCasesData(
+    testData: TestResultRead,
+    { total }: { [key: string]: number },
+    testCasesExecutions: CoderunnerTestCaseExecutionModel[],
+    validTestCases: ExampleTestCase[] | CustomTestCase[]
+  ) {
+    const allTestCasesCount = this.libCodingTestService.getTestCasesCount();
+    const customEmpty = allTestCasesCount - total || 0;
+    const instance = this.getMixpanelInstanceValue(!!testData.is_preview_mode);
+    const { uuid: testUuid } = testData;
+    const { name: testName } = testData.test ?? { name: '' };
+    const mixpanelResults = this.getGroupedTestCaseResult(
+      testCasesExecutions,
+      validTestCases
+    );
+
+    return {
+      testUuid: testUuid?.replace(/-/g, ''),
+      testName,
+      instance,
+      customEmpty,
+      customPassed: mixpanelResults.custom.passed,
+      customFailed: mixpanelResults.custom.failed,
+      examplePassed: mixpanelResults.example.passed,
+      exampleFailed: mixpanelResults.example.failed,
+    };
+  }
+
+  private getGroupedTestCaseResult(
+    testCasesExecutions: CoderunnerTestCaseExecutionModel[],
+    validTestCases: ExampleTestCase[] | CustomTestCase[]
+  ): GroupedTestCasesResult {
+    const groupedResult = {
+      custom: {
+        failed: 0,
+        passed: 0,
+      },
+      example: {
+        failed: 0,
+        passed: 0,
+      },
+    };
+
+    testCasesExecutions.forEach(({ input: resultInput, evaluation }) => {
+      const localTestCase = validTestCases.find(
+        ({ input }) => resultInput === input
+      );
+      const mixpanelResultBody = localTestCase?.preloaded
+        ? groupedResult.example
+        : groupedResult.custom;
+
+      if (evaluation?.testcase) {
+        mixpanelResultBody.passed++;
+      } else {
+        mixpanelResultBody.failed++;
+      }
+    });
+
+    return groupedResult;
+  }
+
+  private getMixpanelSettingsData(
+    isPracticeQuestion: boolean,
+    config: { [key: string]: boolean | string | number }
+  ) {
+    const settingInstance = this.getMixpanelInstanceValue(isPracticeQuestion);
+    const changedKey = Object.keys(config)[0];
+    const THEME_IDENTIFIER = 'theme-';
+    let changedValue: boolean | string | number = config[changedKey];
+    let newValueString;
+
+    if (typeof changedValue === 'boolean') {
+      newValueString = changedValue ? 'ON' : 'OFF';
+    } else {
+      changedValue = String(changedValue);
+      newValueString = changedValue.includes(THEME_IDENTIFIER)
+        ? changedValue.replace(THEME_IDENTIFIER, '')
+        : changedValue;
+    }
+
+    return { settingInstance, changedKey, newValueString };
+  }
+
+  private getMixpanelInstanceValue(isPracticeQuestion: boolean) {
+    return isPracticeQuestion ? 'practice question' : 'real test';
+  }
+
+  private publishTestResults() {
+    this.codingTestResutsSubj$.next({ ...this.codingTestResults });
+  }
+}