@testgorilla/tgo-coding-test 1.0.0 → 2.0.0

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

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