@testgorilla/tgo-coding-test 2.0.0 → 2.0.1

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

@@ -1,599 +0,0 @@
-import { NO_ERRORS_SCHEMA, SimpleChange, SimpleChanges } from '@angular/core';
-import { ComponentFixture, fakeAsync, TestBed, tick, waitForAsync } from '@angular/core/testing';
-import { NoopAnimationsModule } from '@angular/platform-browser/animations';
-import { DomSanitizer } from '@angular/platform-browser';
-import { MockProvider, MockProviders } from 'ng-mocks';
-import { MonacoEditorModule } from 'ngx-monaco-editor-v2';
-import { ReplaySubject, Subject } from 'rxjs';
-
-import { TgoCodingTestComponent } from './tgo-coding-test.component';
-import { CodeEditorLanguages } from '../code-editor/helpers/code-editor-helper.model';
-import { AssessmentIdPreview } from '../../models/lat-languages';
-import { Modes } from '../../models/mode';
-import { ViewMode } from '../../models/view-mode';
-import { ConfigurationsService } from '../../services/configurations.service';
-import { CONFIGURATIONS_SERVICE_MOCK } from '../../services/configurations.service.mocks';
-import { LibCodingTestService } from '../../services/lib-coding-test.service';
-import { StorageCodingService } from '../../services/storage.service';
-import { TestCasesService } from '../../services/test-cases.service';
-import { ThemeService } from '../../services/theme.service';
-
-describe('TgoCodingTestComponent', () => {
-  let component: TgoCodingTestComponent;
-  let fixture: ComponentFixture<TgoCodingTestComponent>;
-  let storageCodingService: StorageCodingService;
-  let configurationsService: ConfigurationsService;
-  let libCodingTestService: LibCodingTestService;
-  let setupAutoSavedDataSpy: jest.SpyInstance;
-  let initializeSavingSpy: jest.SpyInstance;
-  let setCodeComponentDestroyedSpy: jest.SpyInstance;
-  let changeCurrentLanguageSpy: jest.SpyInstance;
-  let setVersionSpy: jest.SpyInstance;
-  let setInitCodeSpy: jest.SpyInstance;
-  let changeLanguageSpy: jest.SpyInstance;
-  let updateInitCodeSpy: jest.SpyInstance;
-  const questionId = 12345;
-
-  beforeEach(waitForAsync(() => {
-    TestBed.configureTestingModule({
-      imports: [TgoCodingTestComponent, MonacoEditorModule.forRoot(), NoopAnimationsModule],
-      schemas: [NO_ERRORS_SCHEMA],
-      providers: [
-        MockProviders(StorageCodingService),
-        MockProvider(TestCasesService, {
-          activeTestCaseIndex$: new ReplaySubject(1),
-          setActiveTestCase: jest.fn(),
-          createTestCaseLocalId: jest.fn(),
-          updateTestCaseLocalId: jest.fn(),
-          resetLastTestCaseLocalId: jest.fn(),
-        }),
-        MockProvider(ThemeService, {
-          themeColors$: new ReplaySubject(1),
-          companyColor: '#46a997',
-        }),
-        MockProvider(ConfigurationsService, CONFIGURATIONS_SERVICE_MOCK),
-        MockProvider(DomSanitizer, {
-          bypassSecurityTrustResourceUrl: val => val,
-          bypassSecurityTrustHtml: val => val,
-          sanitize: (context, value) => (typeof value === 'string' ? value : null),
-        }),
-        MockProvider(LibCodingTestService, {
-          clearSavedCode$: new Subject(),
-          triggerClearSavedCode(): void {
-            this.clearSavedCode$.next(true);
-          },
-          clearLastLang$: new Subject(),
-          currentLanguage$: new ReplaySubject(1),
-          changeCurrentLanguage(value: CodeEditorLanguages): void {
-            this.currentLanguage$.next(value);
-          },
-          languageChange$: new Subject(),
-          codeReset$: new Subject(),
-          themeChanged$: new ReplaySubject(1),
-          testCaseDeletion$: new Subject(),
-          setInitCode: jest.fn(),
-          setVersion: jest.fn(),
-          getVersion: jest.fn().mockReturnValue('1.0'),
-          isFullscreen$: new ReplaySubject(1),
-          setFullscreen(value: boolean): void {
-            this.isFullscreen$.next(value);
-          },
-          updateTestCases: jest.fn(),
-        }),
-      ],
-    })
-    .overrideComponent(TgoCodingTestComponent, {
-      set: {
-        template: '',
-      },
-    })
-    .compileComponents();
-  }));
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(TgoCodingTestComponent);
-    component = fixture.componentInstance;
-    storageCodingService = TestBed.inject(StorageCodingService);
-    configurationsService = TestBed.inject(ConfigurationsService);
-    libCodingTestService = TestBed.inject(LibCodingTestService);
-    updateInitCodeSpy = jest.spyOn(component, 'updateInitCode');
-    setupAutoSavedDataSpy = jest.spyOn(storageCodingService, 'setupAutoSavedData');
-    initializeSavingSpy = jest.spyOn(storageCodingService, 'initializeSaving');
-    changeLanguageSpy = jest.spyOn(storageCodingService, 'changeLanguage');
-    changeCurrentLanguageSpy = jest.spyOn(libCodingTestService, 'changeCurrentLanguage');
-    setVersionSpy = jest.spyOn(libCodingTestService, 'setVersion');
-    setInitCodeSpy = jest.spyOn(libCodingTestService, 'setInitCode');
-    setCodeComponentDestroyedSpy = jest.spyOn(configurationsService, 'setCodeComponentDestroyed');
-    component.viewMode = ViewMode.Full;
-    component.languages = [
-      {
-        value: CodeEditorLanguages.Python,
-        label: 'python',
-        version: '1.23',
-      },
-    ];
-    component.assessmentId = 'abc-def-ghi';
-    component.mode = Modes.Running;
-    component.initCode = 'sample python code';
-    component.questionId = questionId;
-    component.isLAT = true;
-    component.translations = {
-      HEADINGS: {
-        INSTRUCTIONS: 'Instructions',
-        CODING: 'Coding Window',
-        CONFIGURATIONS: 'Configurations',
-        FORMATTING: 'Formatting',
-        CODING_ASSISTANCE: 'Coding Assistance',
-        TESTS: 'Tests',
-      },
-      TOOLTIPS: {
-        RESET_CODE: 'Reset code',
-        HELP: 'Help',
-        MAXIMISE: 'Click to view code-runner in full-screen',
-        MINIMIZE: 'Minimize',
-        CONFIGURATIONS: 'Configurations',
-      },
-      TEST_RESULTS: {
-        RUN_TESTS: 'Run tests',
-        TEST_CASES: {
-          ADD_TEST_CASE: 'Add Test Case',
-          INPUT: 'Input',
-          EXPECTED_OUTPUT: 'Expected output',
-        },
-      },
-      CODE_QUESTION: {
-        LANGUAGE_USING: "For this test you're using",
-      },
-      MODALS: {
-        RESET_CODE: {
-          TITLE: 'Are you sure you want to reset your code?',
-        },
-      },
-    };
-
-    fixture.detectChanges();
-  });
-
-  describe('when initialized', () => {
-    it('should set language in libCodingTestService', () => {
-      expect(changeCurrentLanguageSpy).toBeCalledWith(component.languages[0].value);
-    });
-    it('if version is available, it should set version in libCodingTestService', () => {
-      expect(setVersionSpy).toBeCalledWith(component.languages[0].version);
-    });
-
-    it('should set isFullViewMode to true if viewMode === ViewMode.Full', () => {
-      expect(component.isFullViewMode).toEqual(true);
-    });
-
-    describe('when performing local storage setup in cadidate environment', () => {
-      let clearSavedCodeSpy: jest.SpyInstance;
-      let clearSavedTestCasesSpy: jest.SpyInstance;
-      beforeEach(() => {
-        clearSavedCodeSpy = jest.spyOn(storageCodingService, 'clearSavedCode');
-        clearSavedTestCasesSpy = jest.spyOn(storageCodingService, 'clearSavedTestCases');
-      });
-
-      it('should pass the language, actual assessment ID, Running mode check to setupAutoSavedData', () => {
-        expect(setupAutoSavedDataSpy).toBeCalledWith(
-          component.languages[0].value,
-          component.assessmentId,
-          String(questionId),
-          component.mode === Modes.Running,
-          component.mode === Modes.Running && component.isLAT,
-          component.isLAT,
-          component.mode
-        );
-        expect(setCodeComponentDestroyedSpy).toBeCalledWith(false);
-        expect(updateInitCodeSpy).toBeCalled();
-        expect(initializeSavingSpy).toBeCalled();
-      });
-      describe('when the test is LAT', () => {
-        beforeEach(() => {
-          component.isLAT = true;
-          setupAutoSavedDataSpy.mockReset();
-        });
-        it('should pass the language, assessment ID, true to codeSaveEnabled, false to testCasesSaveEnabled and true to isLAT if the mode is Modes.Preview', () => {
-          component.mode = Modes.Preview;
-          component.ngOnInit();
-          expect(setupAutoSavedDataSpy).toBeCalledWith(
-            component.languages[0].value,
-            component.assessmentId,
-            String(questionId),
-            true,
-            false,
-            true,
-            Modes.Preview
-          );
-          expect(setCodeComponentDestroyedSpy).toBeCalledWith(false);
-          expect(updateInitCodeSpy).toBeCalled();
-          expect(initializeSavingSpy).toBeCalled();
-        });
-        it('should pass the language, preview assessment ID, true to codeSaveEnabled, false to testCasesSaveEnabled and true to isLAT if the mode is Modes.NonAssessmentPreview', () => {
-          setupAutoSavedDataSpy.mockReset();
-          component.mode = Modes.NonAssessmentPreview;
-          component.ngOnInit();
-          expect(setupAutoSavedDataSpy).toBeCalledWith(
-            component.languages[0].value,
-            AssessmentIdPreview,
-            String(questionId),
-            true,
-            false,
-            true,
-            Modes.NonAssessmentPreview
-          );
-          expect(setCodeComponentDestroyedSpy).toBeCalledWith(false);
-          expect(updateInitCodeSpy).toBeCalled();
-          expect(initializeSavingSpy).toBeCalled();
-        });
-
-        it('should pass the language, actual assessment ID, true to codeSaveEnabled, true to testCasesSaveEnabled and true to isLAT if the mode is Modes.Running', () => {
-          setupAutoSavedDataSpy.mockReset();
-          component.mode = Modes.Running;
-          component.ngOnInit();
-          expect(setupAutoSavedDataSpy).toBeCalledWith(
-            component.languages[0].value,
-            component.assessmentId,
-            String(questionId),
-            true,
-            true,
-            true,
-            Modes.Running
-          );
-          expect(setCodeComponentDestroyedSpy).toBeCalledWith(false);
-          expect(updateInitCodeSpy).toBeCalled();
-          expect(initializeSavingSpy).toBeCalled();
-        });
-
-        it('should call clearSavedCode() and clearSavedTestCases() if libCodingTestService.clearSavedCode$ is emitted', fakeAsync(() => {
-          component.mode = Modes.Preview;
-          component.ngOnInit();
-          libCodingTestService.triggerClearSavedCode();
-          tick();
-
-          expect(clearSavedCodeSpy).toHaveBeenCalled();
-          expect(clearSavedTestCasesSpy).toHaveBeenCalled();
-        }));
-      });
-
-      describe('and when mode is Running', () => {
-        beforeEach(() => {
-          component.mode = Modes.Running;
-        });
-
-        it('should call clearSavedCode() if libCodingTestService.clearSavedCode$ is emitted', fakeAsync(() => {
-          component.ngOnInit();
-          libCodingTestService.triggerClearSavedCode();
-          tick();
-
-          expect(clearSavedCodeSpy).toHaveBeenCalled();
-        }));
-      });
-
-      describe('and when isLAT is true', () => {
-        let clearLastLangSpy: jest.SpyInstance;
-
-        beforeEach(() => {
-          component.isLAT = true;
-          clearLastLangSpy = jest.spyOn(storageCodingService, 'clearLastLang');
-        });
-
-        it('should call clearLastLang() if libCodingTestService.clearLastLang$ is emitted', fakeAsync(() => {
-          component.ngOnInit();
-          (libCodingTestService.clearLastLang$ as Subject<any>).next(true);
-          tick();
-
-          expect(clearLastLangSpy).toHaveBeenCalled();
-        }));
-      });
-    });
-
-    describe('when performPeriodicMaintenance is called', () => {
-      let performMaintenanceAndCleanupSpy: jest.SpyInstance;
-      let originalLocalStorage: Storage;
-      let mockLocalStorage: { getItem: jest.Mock; setItem: jest.Mock; clear: jest.Mock };
-      let randomSpy: jest.SpyInstance;
-
-      beforeEach(() => {
-        performMaintenanceAndCleanupSpy = jest.spyOn(storageCodingService, 'performMaintenanceAndCleanup');
-
-        // Save the original localStorage
-        originalLocalStorage = window.localStorage;
-
-        // Create a mock localStorage
-        mockLocalStorage = {
-          getItem: jest.fn(),
-          setItem: jest.fn(),
-          clear: jest.fn(),
-        };
-
-        // Replace localStorage with our mock
-        Object.defineProperty(window, 'localStorage', {
-          value: mockLocalStorage,
-          writable: true,
-        });
-
-        randomSpy = jest.spyOn(Math, 'random');
-      });
-
-      afterEach(() => {
-        performMaintenanceAndCleanupSpy.mockRestore();
-        randomSpy.mockRestore();
-
-        // Restore the original localStorage
-        Object.defineProperty(window, 'localStorage', {
-          value: originalLocalStorage,
-          writable: true,
-        });
-      });
-
-      it('should check localStorage for the maintenance timestamp', () => {
-        component['performPeriodicMaintenance']();
-        expect(mockLocalStorage.getItem).toHaveBeenCalledWith('lastCodingTestStorageMaintenance');
-      });
-
-      it('should call performMaintenanceAndCleanup when maintenance was never done', () => {
-        mockLocalStorage.getItem.mockReturnValue(null);
-        randomSpy.mockReturnValue(0.19);
-
-        component['performPeriodicMaintenance']();
-
-        expect(performMaintenanceAndCleanupSpy).toHaveBeenCalled();
-        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('lastCodingTestStorageMaintenance', expect.any(String));
-      });
-
-      it('should call performMaintenanceAndCleanup when maintenance was done more than a day ago', () => {
-        const oneDayInMs = 24 * 60 * 60 * 1000;
-        const twoDaysAgo = Date.now() - oneDayInMs * 2;
-        mockLocalStorage.getItem.mockReturnValue(twoDaysAgo.toString());
-        randomSpy.mockReturnValue(0.19);
-
-        component['performPeriodicMaintenance']();
-
-        expect(performMaintenanceAndCleanupSpy).toHaveBeenCalled();
-        expect(mockLocalStorage.setItem).toHaveBeenCalledWith('lastCodingTestStorageMaintenance', expect.any(String));
-      });
-
-      it('should not call performMaintenanceAndCleanup when maintenance was done more than a day ago but math random returns more than 0.2', () => {
-        const oneDayInMs = 24 * 60 * 60 * 1000;
-        const twoDaysAgo = Date.now() - oneDayInMs * 2;
-        mockLocalStorage.getItem.mockReturnValue(twoDaysAgo.toString());
-        randomSpy.mockReturnValue(0.2);
-
-        component['performPeriodicMaintenance']();
-
-        expect(performMaintenanceAndCleanupSpy).not.toHaveBeenCalled();
-        expect(mockLocalStorage.setItem).not.toHaveBeenCalled();
-      });
-
-      it('should not call performMaintenanceAndCleanup when maintenance was done recently', () => {
-        const recentTime = Date.now() - 1000; // 1 second ago
-        mockLocalStorage.getItem.mockReturnValue(recentTime.toString());
-
-        component['performPeriodicMaintenance']();
-
-        expect(performMaintenanceAndCleanupSpy).not.toHaveBeenCalled();
-        expect(mockLocalStorage.setItem).not.toHaveBeenCalled();
-      });
-    });
-
-    describe('when isFullViewMode is false', () => {
-      beforeEach(() => {
-        component.viewMode = ViewMode.IDEOnly;
-        component.ngOnInit();
-      });
-
-      it('should not set up storage when not in full view mode', () => {
-        setupAutoSavedDataSpy.mockReset();
-        libCodingTestService.changeCurrentLanguage(component.languages[0].value);
-
-        component.ngOnInit();
-
-        expect(setupAutoSavedDataSpy).not.toHaveBeenCalled();
-      });
-    });
-
-    describe('when questionId is undefined or null', () => {
-      beforeEach(() => {
-        setupAutoSavedDataSpy.mockReset();
-      });
-
-      it('should use default-question-id when questionId is undefined', () => {
-        component.questionId = undefined;
-
-        // Create a spy specifically for this test
-        const setupSpy = jest.spyOn(storageCodingService, 'setupAutoSavedData');
-
-        // Run init
-        libCodingTestService.changeCurrentLanguage(component.languages[0].value);
-
-        component.ngOnInit();
-
-        // Verify the call used the default ID
-        expect(setupSpy).toHaveBeenCalledWith(
-          component.languages[0].value,
-          component.assessmentId,
-          'default-question-id',
-          true,
-          true,
-          true,
-          'running'
-        );
-      });
-
-      it('should use default-question-id when questionId is null', () => {
-        component.questionId = null;
-
-        // Create a spy specifically for this test
-        const setupSpy = jest.spyOn(storageCodingService, 'setupAutoSavedData');
-
-        libCodingTestService.changeCurrentLanguage(component.languages[0].value);
-
-        // Run init
-        component.ngOnInit();
-
-        // Verify the call used the default ID
-        expect(setupSpy).toHaveBeenCalledWith(
-          component.languages[0].value,
-          component.assessmentId,
-          'default-question-id',
-          true,
-          true,
-          true,
-          'running'
-        );
-      });
-    });
-
-    describe('when updateTestCases is called', () => {
-      let resetLastTestCaseLocalIdSpy: jest.SpyInstance;
-      let updateTestCaseLocalIdSpy: jest.SpyInstance;
-      let libUpdateTestCasesSpy: jest.SpyInstance;
-      let storageUpdateTestCasesSpy: jest.SpyInstance;
-      let getSavedTestCasesSpy: jest.SpyInstance;
-
-      beforeEach(() => {
-        updateTestCaseLocalIdSpy = jest.spyOn(TestBed.inject(TestCasesService), 'updateTestCaseLocalId');
-        resetLastTestCaseLocalIdSpy = jest.spyOn(TestBed.inject(TestCasesService), 'resetLastTestCaseLocalId');
-        libUpdateTestCasesSpy = jest.spyOn(libCodingTestService, 'updateTestCases');
-        storageUpdateTestCasesSpy = jest.spyOn(storageCodingService, 'updateTestCases');
-        getSavedTestCasesSpy = jest.spyOn(storageCodingService, 'getSavedTestCases');
-      });
-
-      it('should update test cases when storageTestCasesEnable is true and isLAT is true', () => {
-        component.isLAT = true;
-        component.mode = Modes.Running;
-
-        const mockTestCases = [
-          { id: 1, name: 'Test 1', localId: 101, preloaded: true, input: 'input1', expectedOutput: 'output1' },
-          { id: 2, name: 'Test 2', localId: 102, preloaded: false, input: 'input2', expectedOutput: 'output2' },
-        ];
-
-        getSavedTestCasesSpy.mockReturnValue(mockTestCases);
-
-        component.ngOnInit();
-
-        expect(libUpdateTestCasesSpy).toHaveBeenCalledWith([...mockTestCases]);
-        expect(storageUpdateTestCasesSpy).toHaveBeenCalledWith([...mockTestCases]);
-        expect(updateTestCaseLocalIdSpy).toHaveBeenCalledWith(102);
-      });
-
-      it('should reset test cases when there are no saved test cases', () => {
-        component.isLAT = true;
-        component.mode = Modes.Running;
-
-        getSavedTestCasesSpy.mockReturnValue([]);
-
-        component.ngOnInit();
-
-        expect(libUpdateTestCasesSpy).toHaveBeenCalledWith([]);
-        expect(storageUpdateTestCasesSpy).toHaveBeenCalledWith([]);
-        expect(resetLastTestCaseLocalIdSpy).toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('when initCode is changed', () => {
-    it('should call necessary setters to reflect initCode changes', () => {
-      component.languages = [
-        {
-          value: CodeEditorLanguages.Java,
-          label: 'java',
-        },
-      ];
-      libCodingTestService.changeCurrentLanguage(component.languages[0].value);
-      const oldInitCode = component.initCode;
-      const newInitCode = 'sample java code';
-      component.initCode = newInitCode;
-      const changes: SimpleChanges = {
-        initCode: new SimpleChange(oldInitCode, newInitCode, false),
-      };
-      component.ngOnChanges(changes);
-
-      expect(changeLanguageSpy).toBeCalledWith(component.languages[0].value);
-      expect(setInitCodeSpy).toBeCalledWith(component.initCode);
-      expect(updateInitCodeSpy).toBeCalled();
-    });
-  });
-
-  describe('when updateInitCode is called', () => {
-    let getSavedCodeSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      getSavedCodeSpy = jest.spyOn(storageCodingService, 'getSavedCode');
-    });
-
-    it('should set initCode to savedCode if it exists', () => {
-      const savedCode = 'saved code from storage';
-      getSavedCodeSpy.mockReturnValue(savedCode);
-
-      component.updateInitCode('new code');
-
-      expect(component.initCode).toBe(savedCode);
-    });
-
-    it('should set initCode to provided code if no saved code exists', () => {
-      getSavedCodeSpy.mockReturnValue(null);
-      const newCode = 'new init code';
-
-      component.updateInitCode(newCode);
-
-      expect(component.initCode).toBe(newCode);
-    });
-  });
-
-  describe('when private methods are tested', () => {
-    describe('isSavedLangRelevant method', () => {
-      it('should return false when lastLanguageLAT is null or undefined', () => {
-        expect(component['isSavedLangRelevant'](null)).toBe(false);
-        expect(component['isSavedLangRelevant'](undefined)).toBe(false);
-      });
-
-      it('should return true when lastLanguageLAT matches a language value', () => {
-        component.languages = [
-          { value: CodeEditorLanguages.Python, label: 'python' },
-          { value: CodeEditorLanguages.Typescript, label: 'typescript' },
-        ];
-
-        const lastLang = { value: CodeEditorLanguages.Python, version: '1.0' };
-
-        expect(component['isSavedLangRelevant'](lastLang)).toBe(true);
-      });
-
-      it('should return false when lastLanguageLAT does not match any language value', () => {
-        component.languages = [
-          { value: CodeEditorLanguages.Python, label: 'python' },
-          { value: CodeEditorLanguages.Typescript, label: 'typescript' },
-        ];
-
-        const lastLang = { value: CodeEditorLanguages.Java, version: '1.0' };
-
-        expect(component['isSavedLangRelevant'](lastLang)).toBe(false);
-      });
-    });
-
-    describe('getRelevantLangVersion method', () => {
-      it('should return the version from languages when matching language is found', () => {
-        component.languages = [
-          { value: CodeEditorLanguages.Python, label: 'python', version: '3.9' },
-          { value: CodeEditorLanguages.Typescript, label: 'typescript', version: '4.5' },
-        ];
-
-        const lastLang = { value: CodeEditorLanguages.Python, version: '3.8' };
-
-        expect(component['getRelevantLangVersion'](lastLang)).toBe('3.9');
-      });
-
-      it('should return the version from lastLang when no matching language is found', () => {
-        component.languages = [
-          { value: CodeEditorLanguages.Python, label: 'python', version: '3.9' },
-          { value: CodeEditorLanguages.Typescript, label: 'typescript', version: '4.5' },
-        ];
-
-        const lastLang = { value: CodeEditorLanguages.Java, version: '11' };
-
-        expect(component['getRelevantLangVersion'](lastLang)).toBe('11');
-      });
-    });
-  });
-});