@testgorilla/tgo-coding-test 0.0.1

package/src/lib/components/tgo-coding-test-candidate-view/tgo-coding-test-candidate-view.component.spec.ts

@@ -0,0 +1,883 @@
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import {
+  ComponentFixture,
+  fakeAsync,
+  flush,
+  TestBed,
+  tick,
+  discardPeriodicTasks,
+} from '@angular/core/testing';
+import { ActivatedRoute } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+import { TranslocoService } from '@ngneat/transloco';
+import {
+  ApiService,
+  getTranslocoModule,
+  Question,
+  TestResultRead,
+  ThemeService,
+  EnvironmentService,
+} from '@testgorilla/tgo-test-shared';
+import { DialogService } from '@testgorilla/tgo-ui';
+import { of, Subject } from 'rxjs';
+
+import {
+  mockAssessment,
+  mockQuestion,
+  mockSQLTestCases,
+  mockTestCases,
+  mockTestResultRead,
+} from '@testgorilla/tgo-test-shared';
+import en from '../../../assets/i18n/en.json';
+import { ProgrammingLanguage, ProgrammingLanguageVersioned } from '../../models/programming-language';
+import { TgoCodingTestCandidateViewComponent } from './tgo-coding-test-candidate-view.component';
+import { CandidatureApiService } from '../../services/candidate-coding-test-services/candidature-api.service';
+import { CoderunnerApiService } from '../../services/candidate-coding-test-services/coderunner-api.service';
+import { CodingTestTourService } from '../../services/candidate-coding-test-services/coding-test-tour.service';
+import { CodingTestService } from '../../services/candidate-coding-test-services/coding-test.service';
+import { PasteData } from '../../models/paste-data';
+import { LibCodingTestService } from '../../services/lib-coding-test.service';
+import { TestCaseDeletionAction } from '../../models/test-cases';
+import { Modes } from '../../models/mode';
+import { CodeEditorLanguages } from '../code-editor/helpers/code-editor-helper.model';
+import { CodingTestConfigService } from '../../services/coding-test-config.service';
+import { TGO_CODING_TEST_CONFIG } from '../../config/tgo-coding-test.token';
+
+describe('TgoCodingTestCandidateViewComponent', () => {
+  let component: TgoCodingTestCandidateViewComponent;
+  let fixture: ComponentFixture<TgoCodingTestCandidateViewComponent>;
+  let codingTestServiceMock: Partial<jest.Mocked<CodingTestService>>;
+  let codingTestTourServiceMock: Partial<jest.Mocked<CodingTestTourService>>;
+  let candidatureApiServiceMock: Partial<jest.Mocked<CandidatureApiService>>;
+  let apiServiceMock: Partial<jest.Mocked<ApiService>>;
+  let transLocoServiceMock: Partial<jest.Mocked<TranslocoService>>;
+  let libCodingTestServiceMock: Partial<jest.Mocked<LibCodingTestService>>;
+  let environmentServiceMock: Partial<jest.Mocked<EnvironmentService>>;
+  let dialogServiceMock: Partial<jest.Mocked<DialogService>>;
+  let codingTestConfigServiceMock: Partial<jest.Mocked<CodingTestConfigService>>;
+  const companyColor = '#D410AA';
+  const mockApiUrl = 'http://localhost:4100/api/';
+
+  beforeEach(async () => {
+    apiServiceMock = {
+      setParams: jest.fn(),
+    };
+
+    codingTestServiceMock = {
+      runTest: jest.fn(),
+      handleLanguageChangeModal: jest.fn(),
+      handleDeleteTestCaseModal: jest.fn(),
+      getCurrentLanguageLAT: jest.fn(),
+      setCurrentLanguageLAT: jest.fn(),
+      setSqlTestCases: jest.fn(),
+      setTest: jest.fn(),
+      setIsSQLTest: jest.fn(),
+      listenCodingTestChanges: jest.fn().mockReturnValue(of()),
+      trackConfigChanged: jest.fn(),
+      listenDeleteCustomTestCases: jest.fn().mockReturnValue(
+        of({ index: 1, action: TestCaseDeletionAction.Try })
+      ),
+      transformToExampleLATtestCase: jest.fn(),
+      transformToExampleSQLTestCase: jest.fn(),
+      codingTestResults$: of({
+        listResponse: [],
+        resume: { ok: 0, error: 0, total: 0 },
+      }),
+      sendCopypasteEvent$: jest.fn().mockReturnValue(of(null)),
+      sendAutosaveEvent$: jest.fn().mockReturnValue(of({} as any)),
+      isTestResultsLoading: jest.fn().mockReturnValue(false),
+      handleResetCodeModal: jest.fn(),
+          } as unknown as Partial<jest.Mocked<CodingTestService>>;
+
+    codingTestTourServiceMock = {
+      init: jest.fn(),
+      activeGuidedTourId$: of('fake-id'),
+    };
+
+    candidatureApiServiceMock = {
+      getAvailableLanguages$: jest.fn().mockReturnValue(of([])),
+    } as Partial<jest.Mocked<CandidatureApiService>>;
+
+    libCodingTestServiceMock = {
+      currentLanguage$: of(CodeEditorLanguages.Javascript),
+      startGuidedTour$: new Subject(),
+      themeChanged$: of('light' as any),
+      isFullscreen$: of(false),
+      setBoilerplateLoadingStatus: jest.fn(),
+      triggerClearSavedCode: jest.fn(),
+      clearLastLanguageSelected: jest.fn(),
+      getVersion: jest.fn().mockReturnValue('1.0.0'),
+    } as Partial<jest.Mocked<LibCodingTestService>>;
+
+    environmentServiceMock = {} as Partial<jest.Mocked<EnvironmentService>>;
+    Object.defineProperty(environmentServiceMock, 'isMobile', {
+      writable: true,
+      value: false
+    });
+
+    transLocoServiceMock = {
+      selectTranslateObject: jest
+        .fn()
+        .mockReturnValue(of({ testTranslationKey: 'test-translation' })),
+    };
+
+    dialogServiceMock = {
+      open: jest.fn().mockReturnValue({
+        afterClosed: jest.fn().mockReturnValue(of(true))
+      })
+    };
+
+    codingTestConfigServiceMock = {
+      getApiUrl: jest.fn().mockReturnValue(mockApiUrl),
+      getCoderunnerV2Endpoint: jest.fn().mockReturnValue('https://cr-v2-staging.testgorilla.com'),
+    } as Partial<jest.Mocked<CodingTestConfigService>>;
+
+    await TestBed.configureTestingModule({
+      declarations: [],
+      imports: [
+        TgoCodingTestCandidateViewComponent,
+        RouterTestingModule,
+        HttpClientTestingModule,
+        getTranslocoModule({ langs: { en } }),
+      ],
+      schemas: [NO_ERRORS_SCHEMA],
+    })
+      .overrideComponent(TgoCodingTestCandidateViewComponent, {
+        add: {
+          providers: [
+            {
+              provide: ActivatedRoute,
+              useValue: {
+                snapshot: { firstChild: { url: [{ path: 'test-id' }] } },
+              },
+            },
+            { provide: CodingTestService, useValue: codingTestServiceMock },
+            {
+              provide: CodingTestTourService,
+              useValue: codingTestTourServiceMock,
+            },
+            {
+              provide: ThemeService,
+              useValue: {
+                uiTheme: 'dark',
+                getCompanyColor: jest.fn().mockReturnValue(companyColor),
+              },
+            },
+            { provide: CoderunnerApiService },
+            {
+              provide: CandidatureApiService,
+              useValue: candidatureApiServiceMock,
+            },
+            { provide: ApiService, useValue: apiServiceMock },
+            { provide: TranslocoService, useValue: transLocoServiceMock },
+            { provide: LibCodingTestService, useValue: libCodingTestServiceMock },
+            { provide: EnvironmentService, useValue: environmentServiceMock },
+            { provide: DialogService, useValue: dialogServiceMock },
+            { provide: CodingTestConfigService, useValue: codingTestConfigServiceMock },
+            {
+              provide: TGO_CODING_TEST_CONFIG,
+              useValue: {
+                apiUrl: mockApiUrl,
+                coderunnerV2Endpoint: 'https://cr-v2-staging.testgorilla.com',
+              },
+            },
+          ],
+        },
+      })
+      .compileComponents();
+
+    fixture = TestBed.createComponent(TgoCodingTestCandidateViewComponent);
+    component = fixture.componentInstance;
+  });
+
+  describe('when component is initialized', () => {
+    it('should create and initialize default values', () => {
+      expect(component).toBeTruthy();
+      expect(component.hostClass).toBe('micro-question-code');
+      expect(component.isSQL).toBe(false);
+      expect(component.isLAT).toBe(true);
+    });
+  });
+
+  describe('when ngOnInit is called', () => {
+    describe('and test is not SQL', () => {
+      it('should setup no SQL test state', fakeAsync(() => {
+        component.test = mockTestResultRead;
+        component.question = mockQuestion;
+        component.question.context.testcases = mockTestCases;
+        jest.spyOn(apiServiceMock, 'setParams');
+        jest
+          .spyOn(codingTestServiceMock, 'listenCodingTestChanges')
+          .mockReturnValue(of());
+        jest.spyOn(codingTestServiceMock, 'trackConfigChanged');
+        jest
+          .spyOn(codingTestServiceMock, 'listenDeleteCustomTestCases')
+          .mockReturnValue(
+            of({ index: 1, action: TestCaseDeletionAction.Try })
+          );
+        jest.spyOn(transLocoServiceMock, 'selectTranslateObject');
+
+        component.ngOnInit();
+        expect(apiServiceMock.setParams).toHaveBeenCalledWith(
+          'test-id',
+          mockAssessment.locale,
+          'CODING_QUESTION',
+          mockApiUrl
+        );
+        expect(component.isSQL).toBe(false);
+        expect(component.isLAT).toBe(true);
+        expect(component.mode).toBe(Modes.Preview);
+        expect(
+          codingTestServiceMock.listenCodingTestChanges
+        ).toHaveBeenCalled();
+        expect(codingTestServiceMock.trackConfigChanged).toHaveBeenCalled();
+        expect(
+          codingTestServiceMock.listenDeleteCustomTestCases
+        ).toHaveBeenCalled();
+        expect(transLocoServiceMock.selectTranslateObject).toHaveBeenCalled();
+        expect(component.codingLibTranslations()).toEqual({
+          testTranslationKey: 'test-translation',
+        });
+        flush();
+      }));
+
+      it('should setup autosave when not in preview mode', fakeAsync(() => {
+        component.test = { ...mockTestResultRead, is_preview_mode: false };
+        component.question = mockQuestion;
+        component.question.context.testcases = mockTestCases;
+        jest.spyOn(codingTestServiceMock, 'sendAutosaveEvent$').mockReturnValue(of({} as any));
+
+        component.ngOnInit();
+
+        // Fast forward 5 seconds to trigger autosave
+        tick(5000);
+
+        expect(codingTestServiceMock.sendAutosaveEvent$).toHaveBeenCalledWith(
+          component.code,
+          component.question.id
+        );
+
+        // Clean up any remaining periodic timers
+        discardPeriodicTasks();
+        flush();
+      }));
+    });
+
+    describe('and test is SQL', () => {
+      it('should setup the SQL test state', fakeAsync(() => {
+        component.test = mockTestResultRead;
+        component.test.is_preview_mode = false;
+        component.question = mockQuestion;
+        component.question.context.code_language = 'sql';
+        component.question.context.sql_testcases = mockSQLTestCases;
+        component.question.context.initial_sql =
+          mockSQLTestCases[0].initial_sql;
+        jest.spyOn(apiServiceMock, 'setParams');
+        jest.spyOn(codingTestServiceMock, 'setSqlTestCases');
+        jest.spyOn(codingTestServiceMock, 'listenCodingTestChanges');
+        jest.spyOn(codingTestServiceMock, 'trackConfigChanged');
+        jest.spyOn(transLocoServiceMock, 'selectTranslateObject');
+
+        component.ngOnInit();
+        expect(component.isSQL).toBe(true);
+        expect(component.isLAT).toBe(false);
+        expect(component.mode).toBe(Modes.Running);
+        expect(apiServiceMock.setParams).toHaveBeenCalledWith(
+          'test-id',
+          mockAssessment.locale,
+          'CODING_QUESTION',
+          mockApiUrl
+        );
+        expect(codingTestServiceMock.setSqlTestCases).toHaveBeenCalledWith(
+          mockSQLTestCases
+        );
+        expect(
+          codingTestServiceMock.listenCodingTestChanges
+        ).toHaveBeenCalled();
+        expect(codingTestServiceMock.trackConfigChanged).toHaveBeenCalled();
+        expect(transLocoServiceMock.selectTranslateObject).toHaveBeenCalled();
+        tick();
+        flush();
+        expect(component.codingLibTranslations()).toEqual({
+          testTranslationKey: 'test-translation',
+        });
+        component.ngOnDestroy();
+      }));
+    });
+
+    describe('additional edge cases', () => {
+      it('should handle expiration observable when provided', fakeAsync(() => {
+        const expirationSubject = new Subject<void>();
+        component.expirationObservable = expirationSubject.asObservable();
+        component.test = { ...mockTestResultRead, is_preview_mode: false };
+        component.question = {
+          ...mockQuestion,
+          context: { ...mockQuestion.context, code_language: 'javascript' }
+        };
+        component.code = 'test code';
+        component.currentLanguage = 'javascript';
+        component.isSQL = false;
+        jest.spyOn(libCodingTestServiceMock, 'triggerClearSavedCode');
+        jest.spyOn(libCodingTestServiceMock, 'clearLastLanguageSelected');
+        jest.spyOn(component.submissionStateChanged, 'emit');
+        jest.spyOn(component.configurationStateChanged, 'emit');
+
+        component.ngOnInit();
+
+        // Trigger expiration
+        expirationSubject.next();
+        tick();
+
+        expect(libCodingTestServiceMock.triggerClearSavedCode).toHaveBeenCalled();
+        expect(libCodingTestServiceMock.clearLastLanguageSelected).toHaveBeenCalled();
+        expect(component.submissionStateChanged.emit).toHaveBeenCalledWith({
+          text: 'test code',
+          language: 'javascript-1.0.0',
+        });
+        expect(component.configurationStateChanged.emit).toHaveBeenCalledWith({
+          isSavingQuestionDisabled: false,
+        });
+        discardPeriodicTasks();
+        flush();
+      }));
+
+      it('should handle complete observable when provided', fakeAsync(() => {
+        const completeSubject = new Subject<void>();
+        component.completeObservable = completeSubject.asObservable();
+        component.test = { ...mockTestResultRead, is_preview_mode: false };
+        component.question = mockQuestion;
+
+        component.ngOnInit();
+
+        // Trigger completion
+        completeSubject.next();
+        tick();
+
+        expect(dialogServiceMock.open).toHaveBeenCalled();
+        discardPeriodicTasks();
+        flush();
+      }));
+
+      it('should handle complete observable in preview mode', fakeAsync(() => {
+        const completeSubject = new Subject<void>();
+        component.completeObservable = completeSubject.asObservable();
+        component.test = { ...mockTestResultRead, is_preview_mode: true };
+        component.question = mockQuestion;
+        jest.spyOn(libCodingTestServiceMock, 'triggerClearSavedCode');
+
+        component.ngOnInit();
+
+        // Trigger completion
+        completeSubject.next();
+        tick();
+
+        expect(libCodingTestServiceMock.triggerClearSavedCode).toHaveBeenCalled();
+        flush();
+      }));
+
+      it('should handle language change without current language found', fakeAsync(() => {
+        component.question = {
+          ...mockQuestion,
+          context: {
+            ...mockQuestion.context,
+            boilerplates: [
+              {
+                programming_language: { id: 1, name: 'javascript', version: '1.0' },
+                code: 'console.log("hello");'
+              }
+            ]
+          }
+        };
+        candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([]));
+        libCodingTestServiceMock.currentLanguage$ = of('python' as any); // Language not in rawLanguages
+        jest.spyOn(codingTestServiceMock, 'setCurrentLanguageLAT');
+
+        component['loadAvailableLanguages']();
+        tick();
+
+        expect(codingTestServiceMock.setCurrentLanguageLAT).not.toHaveBeenCalled();
+        flush();
+      }));
+
+      it('should handle language change without init code', fakeAsync(() => {
+        component.question = {
+          ...mockQuestion,
+          context: {
+            ...mockQuestion.context,
+            boilerplates: [
+              {
+                programming_language: { id: 1, name: 'javascript', version: '1.0' },
+                code: 'console.log("hello");'
+              }
+            ]
+          }
+        };
+        candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([]));
+        libCodingTestServiceMock.currentLanguage$ = of('python' as any); // Language not in initCodesMap
+        jest.spyOn(component, 'updateCode');
+
+        component['loadAvailableLanguages']();
+        tick();
+
+        expect(component.updateCode).not.toHaveBeenCalled();
+        flush();
+      }));
+    });
+  });
+
+  describe('when loadAvailableLanguages is called', () => {
+    beforeEach(() => {
+      component.question = {
+        ...mockQuestion,
+        context: {
+          ...mockQuestion.context,
+          boilerplates: [
+            {
+              programming_language: { id: 1, name: 'javascript', version: '1.0' },
+              code: 'console.log("hello");'
+            },
+            {
+              programming_language: { id: 2, name: 'python', version: '3.8' },
+              code: 'print("hello")'
+            },
+            {
+              programming_language: { id: 3, name: '', version: '1.0' }, // Test edge case with empty name
+              code: 'test code'
+            }
+          ]
+        }
+      };
+    });
+
+    it('should load all languages when no restrictions', fakeAsync(() => {
+      candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([]));
+      jest.spyOn(component.loadingStateChanged, 'emit');
+      jest.spyOn(libCodingTestServiceMock, 'setBoilerplateLoadingStatus');
+
+      component['loadAvailableLanguages']();
+      tick();
+
+      expect(component.rawLanguages).toHaveLength(3);
+      expect(component.languages()).toEqual([
+        { label: 'Javascript', value: 'javascript', version: '1.0' },
+        { label: 'Python', value: 'python', version: '3.8' },
+        { label: 'Unknown', value: '', version: '1.0' }
+      ]);
+      expect(component.loadingStateChanged.emit).toHaveBeenCalledWith(false);
+      expect(libCodingTestServiceMock.setBoilerplateLoadingStatus).toHaveBeenCalledWith(false);
+      expect(component.initCodesMap.get('javascript' as CodeEditorLanguages)).toBe('console.log("hello");');
+      expect(component.initCodesMap.get('python' as CodeEditorLanguages)).toBe('print("hello")');
+      flush();
+    }));
+
+    it('should filter languages based on available language ids', fakeAsync(() => {
+      candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([1]));
+      jest.spyOn(codingTestServiceMock, 'setCurrentLanguageLAT');
+
+      component['loadAvailableLanguages']();
+      tick();
+
+      expect(component.rawLanguages).toHaveLength(1);
+      expect(component.rawLanguages[0].name).toBe('javascript');
+      expect(codingTestServiceMock.setCurrentLanguageLAT).toHaveBeenCalledWith(
+        component.rawLanguages[0]
+      );
+      flush();
+    }));
+
+    it('should handle language change and update init code', fakeAsync(() => {
+      candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([]));
+      jest.spyOn(component, 'updateCode');
+
+      component['loadAvailableLanguages']();
+      tick();
+
+      expect(component.initCode).toBe('console.log("hello");');
+      expect(component.updateCode).toHaveBeenCalledWith('console.log("hello");');
+      flush();
+    }));
+
+    it('should skip boilerplates without programming language name', fakeAsync(() => {
+      component.question.context.boilerplates = [
+        {
+          programming_language: { id: 1, name: null as any, version: '1.0' },
+          code: 'test code'
+        }
+      ];
+      candidatureApiServiceMock.getAvailableLanguages$ = jest.fn().mockReturnValue(of([]));
+
+      component['loadAvailableLanguages']();
+      tick();
+
+      expect(component.initCodesMap.size).toBe(0);
+      flush();
+    }));
+  });
+
+  describe('when languageChange method is called', () => {
+    it('should call the handleLanguageChangeModal method with right theme and language', () => {
+      component.rawLanguages = [
+        { name: 'javascript' },
+      ] as ProgrammingLanguage[];
+      const resultId = 1;
+      const questionId = 2;
+      component.question = {
+        id: resultId,
+        question_id: questionId,
+      } as Question;
+      jest.spyOn(codingTestServiceMock, 'handleLanguageChangeModal');
+      component.languageChange(CodeEditorLanguages.Javascript);
+      expect(
+        codingTestServiceMock.handleLanguageChangeModal
+      ).toHaveBeenCalledWith(resultId, { name: 'javascript' }, 'light', companyColor);
+    });
+  });
+
+  describe('when updateCode method is called', () => {
+    it('should set new code value', () => {
+      const code = 'sample new code';
+      component.updateCode(code);
+      expect(component.code).toEqual(code);
+    });
+  });
+
+  describe('when runTest method is called', () => {
+    describe('and test is language agnostic', () => {
+      it('should emit LATRunTestClicked and call runTest method of CodingTestService', () => {
+        const resultId = 1;
+        const questionId = 2;
+        const testResultId = 3;
+
+        component.isLAT = true;
+        component.isSQL = false;
+        component.code = 'test code';
+        component.test = {
+          id: testResultId,
+          is_preview_mode: false,
+        } as TestResultRead;
+        component.question = {
+          id: resultId,
+          question_id: questionId,
+        } as Question;
+        jest.spyOn(component.navigationButtonStateChanged, 'emit');
+
+        component.runTest();
+
+        expect(codingTestServiceMock.runTest).toHaveBeenCalledWith(
+          resultId,
+          'test code',
+          true,
+          false,
+          false,
+          false,
+          questionId,
+          testResultId,
+          component.test
+        );
+        expect(component.navigationButtonStateChanged.emit).toHaveBeenCalledWith({
+          disabled: false,
+        });
+        expect(component.firstTestRunComplete).toBe(true);
+      });
+
+      it('should not emit navigation button state change if first test run already complete', () => {
+        component.firstTestRunComplete = true;
+        component.isLAT = true;
+        component.isSQL = false;
+        component.code = 'test code';
+        component.test = { id: 1, is_preview_mode: false } as TestResultRead;
+        component.question = { id: 1, question_id: 2 } as Question;
+        jest.spyOn(component.navigationButtonStateChanged, 'emit');
+
+        component.runTest();
+
+        expect(component.navigationButtonStateChanged.emit).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('when screenshotPaste method is called', () => {
+    const code = 'existing code';
+    const pastedData = 'pasted text';
+    const pasteEvent = { type: 'paste', data: pastedData };
+
+    describe('and event type is paste', () => {
+      it('should call sendCopypasteEvent$', () => {
+        component.isLAT = true;
+        component.code = code;
+        component.question = mockQuestion;
+        component.screenshotPaste(pasteEvent);
+        expect(codingTestServiceMock.sendCopypasteEvent$).toHaveBeenCalledWith(
+          code,
+          pastedData,
+          mockQuestion.id
+        );
+      });
+    });
+
+    describe('and type is NOT paste', () => {
+      it('should NOT call sendCopypasteEvent$', () => {
+        component.screenshotPaste({ type: 'any' } as PasteData);
+        expect(
+          codingTestServiceMock.sendCopypasteEvent$
+        ).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('when openSaveDialog is called', () => {
+    it('should open confirm dialog and handle confirmation', () => {
+      jest.spyOn(component.configurationStateChanged, 'emit');
+      jest.spyOn(libCodingTestServiceMock, 'triggerClearSavedCode');
+      jest.spyOn(libCodingTestServiceMock, 'clearLastLanguageSelected');
+      jest.spyOn(component.submissionStateChanged, 'emit');
+
+      component.code = 'test code';
+      component.currentLanguage = 'javascript';
+      component.isSQL = false;
+      component.openSaveDialog();
+
+      expect(dialogServiceMock.open).toHaveBeenCalled();
+      expect(libCodingTestServiceMock.triggerClearSavedCode).toHaveBeenCalled();
+      expect(libCodingTestServiceMock.clearLastLanguageSelected).toHaveBeenCalled();
+      expect(component.submissionStateChanged.emit).toHaveBeenCalledWith({
+        text: 'test code',
+        language: 'javascript-1.0.0',
+      });
+      expect(component.configurationStateChanged.emit).toHaveBeenCalledWith({
+        isSavingQuestionDisabled: false,
+      });
+    });
+
+    it('should not submit if dialog is cancelled', () => {
+      dialogServiceMock.open = jest.fn().mockReturnValue({
+        afterClosed: jest.fn().mockReturnValue(of(false))
+      });
+      jest.spyOn(component.submissionStateChanged, 'emit');
+
+      component.openSaveDialog();
+
+      expect(component.submissionStateChanged.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('ngOnDestroy', () => {
+    it('should emit anti-cheating configuration when not in preview mode', () => {
+      component.test = { is_preview_mode: false } as TestResultRead;
+      jest.spyOn(component.antiCheatingConfigurationChanged, 'emit');
+
+      component.ngOnDestroy();
+
+      expect(component.antiCheatingConfigurationChanged.emit).toHaveBeenCalledWith({
+        fullscreenTracking: false,
+        mouseEventTracking: false,
+        snapshotsTracking: false,
+      });
+    });
+
+    it('should not emit anti-cheating configuration when in preview mode', () => {
+      component.test = { is_preview_mode: true } as TestResultRead;
+      jest.spyOn(component.antiCheatingConfigurationChanged, 'emit');
+
+      component.ngOnDestroy();
+
+      expect(component.antiCheatingConfigurationChanged.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('private methods', () => {
+    describe('getAllLanguages', () => {
+      it('should return programming languages from boilerplates', () => {
+        component.question = {
+          context: {
+            boilerplates: [
+              { programming_language: { name: 'javascript' } },
+              { programming_language: { name: 'python' } }
+            ]
+          }
+        } as any;
+
+        const result = component['getAllLanguages']();
+
+        expect(result).toEqual([
+          { name: 'javascript' },
+          { name: 'python' }
+        ]);
+      });
+
+      it('should return empty array when no boilerplates', () => {
+        component.question = { context: {} } as any;
+
+        const result = component['getAllLanguages']();
+
+        expect(result).toEqual([]);
+      });
+    });
+
+    describe('setupState', () => {
+      it('should call all setup methods', () => {
+        component.test = mockTestResultRead;
+        component.question = { ...mockQuestion, context: { ...mockQuestion.context, code_language: 'javascript' } };
+        component.assessment = mockAssessment;
+        jest.spyOn(apiServiceMock, 'setParams');
+        jest.spyOn(transLocoServiceMock, 'selectTranslateObject');
+        jest.spyOn(codingTestServiceMock, 'setIsSQLTest');
+
+        component['setupState']();
+
+        expect(apiServiceMock.setParams).toHaveBeenCalled();
+        expect(transLocoServiceMock.selectTranslateObject).toHaveBeenCalled();
+        expect(codingTestServiceMock.setIsSQLTest).toHaveBeenCalledWith(false);
+      });
+    });
+
+    describe('handleGuidedTour', () => {
+      it('should initialize guided tour for preview mode on desktop', fakeAsync(() => {
+        Object.defineProperty(environmentServiceMock, 'isMobile', { value: false });
+        component.test = { is_preview_mode: true } as TestResultRead;
+        jest.spyOn(codingTestTourServiceMock, 'init');
+
+        component['handleGuidedTour']();
+        tick(1500);
+
+        expect(codingTestTourServiceMock.init).toHaveBeenCalled();
+        expect(component['wasTourShown']).toBe(true);
+      }));
+
+      it('should not initialize guided tour on mobile', fakeAsync(() => {
+        Object.defineProperty(environmentServiceMock, 'isMobile', { value: true });
+        component.test = { is_preview_mode: true } as TestResultRead;
+        jest.spyOn(codingTestTourServiceMock, 'init');
+
+        component['handleGuidedTour']();
+        tick(1500);
+
+        expect(codingTestTourServiceMock.init).not.toHaveBeenCalled();
+      }));
+
+      it('should not initialize guided tour when already shown', fakeAsync(() => {
+        Object.defineProperty(environmentServiceMock, 'isMobile', { value: false });
+        component.test = { is_preview_mode: true } as TestResultRead;
+        component['wasTourShown'] = true;
+        jest.spyOn(codingTestTourServiceMock, 'init');
+
+        component['handleGuidedTour']();
+        tick(1500);
+
+        expect(codingTestTourServiceMock.init).not.toHaveBeenCalled();
+      }));
+    });
+  });
+
+  describe('getVersionedLanguage', () => {
+    beforeEach(() => {
+      component.test = mockTestResultRead;
+      component.question = mockQuestion;
+    });
+
+    it('should return language with version for LAT tests', () => {
+      component.isSQL = false;
+      component.currentLanguage = 'javascript';
+
+      const result = component['getVersionedLanguage']();
+
+      expect(result).toBe('javascript-1.0.0');
+    });
+
+    it('should return SQLite for SQL tests', () => {
+      component.isSQL = true;
+      component.currentLanguage = 'sql';
+
+      const result = component['getVersionedLanguage']();
+
+      expect(result).toBe(ProgrammingLanguageVersioned.SQLite);
+    });
+
+    it('should return undefined when no language is selected', () => {
+      component.currentLanguage = undefined;
+
+      const result = component['getVersionedLanguage']();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('submitCode with language', () => {
+    beforeEach(() => {
+      component.test = mockTestResultRead;
+      component.question = mockQuestion;
+      jest.spyOn(component.submissionStateChanged, 'emit');
+    });
+
+    it('should emit submission with language for LAT test', () => {
+      component.isSQL = false;
+      component.code = 'console.log("test");';
+      component.currentLanguage = 'javascript';
+
+      component['submitCode']();
+
+      expect(component.submissionStateChanged.emit).toHaveBeenCalledWith({
+        text: 'console.log("test");',
+        language: 'javascript-1.0.0',
+      });
+    });
+
+    it('should emit submission with SQLite for SQL test', () => {
+      component.isSQL = true;
+      component.code = 'SELECT * FROM users;';
+      component.currentLanguage = 'sql';
+
+      component['submitCode']();
+
+      expect(component.submissionStateChanged.emit).toHaveBeenCalledWith({
+        text: 'SELECT * FROM users;',
+        language: ProgrammingLanguageVersioned.SQLite,
+      });
+    });
+
+    it('should emit submission without language when no language is selected', () => {
+      component.code = 'test code';
+      component.currentLanguage = undefined;
+
+      component['submitCode']();
+
+      expect(component.submissionStateChanged.emit).toHaveBeenCalledWith({
+        text: 'test code',
+        language: undefined,
+      });
+    });
+
+    it('should not emit when code is empty', () => {
+      component.code = '';
+      component.currentLanguage = 'javascript';
+
+      component['submitCode']();
+
+      expect(component.submissionStateChanged.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('language initialization', () => {
+    it('should set currentLanguage when setSqlLang is called', () => {
+      component.question = {
+        ...mockQuestion,
+        context: { ...mockQuestion.context, code_language: 'sql' }
+      };
+
+      component['setSqlLang']();
+
+      expect(component.currentLanguage).toBe('sql');
+    });
+
+    it('should set currentLanguage when listenLanguageChange receives a language', () => {
+      const languageSubject = new Subject<CodeEditorLanguages>();
+      libCodingTestServiceMock.currentLanguage$ = languageSubject.asObservable();
+
+      component['listenLanguageChange']();
+      languageSubject.next(CodeEditorLanguages.Python);
+
+      expect(component.currentLanguage).toBe('python');
+    });
+  });
+});