@testgorilla/tgo-coding-test 2.0.0 → 2.0.1

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

@@ -1,843 +0,0 @@
-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 });
-  }
-}