@testgorilla/tgo-coding-test 0.0.1

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

@@ -0,0 +1,4 @@
+export * from './coding-test.service';
+export * from './coding-test-tour.service';
+export * from './candidature-api.service';
+export * from './coderunner-api.service';

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

@@ -0,0 +1,48 @@
+import { inject, Injectable } from '@angular/core';
+import { TGO_CODING_TEST_CONFIG } from '../config/tgo-coding-test.token';
+
+/**
+ * Service for accessing TGO Coding Test library configuration.
+ * 
+ * This service provides a clean abstraction layer over the configuration
+ * injection token, allowing services to access configuration values
+ * without directly injecting the token.
+ * 
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   private readonly configService = inject(CodingTestConfigService);
+ *   
+ *   doSomething() {
+ *     const endpoint = this.configService.getCoderunnerV2Endpoint();
+ *     // Use endpoint...
+ *   }
+ * }
+ * ```
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class CodingTestConfigService {
+  private readonly config = inject(TGO_CODING_TEST_CONFIG);
+
+  /**
+   * Gets the main API endpoint URL.
+   * 
+   * @returns The base URL for the main API endpoint
+   */
+  getApiUrl(): string {
+    return this.config.apiUrl;
+  }
+
+  /**
+   * Gets the CodeRunner V2 API endpoint URL.
+   * 
+   * @returns The base URL for the CodeRunner V2 API endpoint
+   */
+  getCoderunnerV2Endpoint(): string {
+    return this.config.coderunnerV2Endpoint;
+  }
+}
+

package/src/lib/services/configurations.service.mocks.ts

@@ -0,0 +1,77 @@
+import { BehaviorSubject } from 'rxjs';
+import { CodingAssistanceOptions, Config, FormattingOptions } from '../models/configs';
+import { Themes } from '../models/theme';
+
+const defaultConfigs = {
+  [FormattingOptions.ColorTheme]: Themes.Default,
+  [FormattingOptions.TabSize]: 4,
+  [FormattingOptions.FontSize]: 14,
+  [CodingAssistanceOptions.AutoComplete]: true,
+  [CodingAssistanceOptions.ErrorHighlighting]: true,
+  [CodingAssistanceOptions.AutoBrackets]: true,
+};
+
+export const CONFIGURATIONS_SERVICE_MOCK = {
+  defaultConfigs,
+
+  formattingOptions: {
+    [FormattingOptions.ColorTheme]: [
+      { label: 'Light', value: Themes.Default },
+      { label: 'Dark', value: Themes.Dark },
+    ],
+    [FormattingOptions.TabSize]: [
+      { label: '4 (default)', value: 4 },
+      { label: '2', value: 2 },
+      { label: '3', value: 3 },
+      { label: '5', value: 5 },
+      { label: '8', value: 8 },
+    ],
+    [FormattingOptions.FontSize]: [
+      { label: '10px', value: 10 },
+      { label: '12px', value: 12 },
+      { label: '14px (default)', value: 14 },
+      { label: '16px', value: 16 },
+      { label: '18px', value: 18 },
+      { label: '20px', value: 20 },
+    ],
+  },
+
+  codingAssistanceOptions: {
+    [CodingAssistanceOptions.AutoComplete]: true,
+    [CodingAssistanceOptions.ErrorHighlighting]: true,
+    [CodingAssistanceOptions.AutoBrackets]: true,
+  },
+
+  codeComponentDestroyed: true,
+  config$: new BehaviorSubject(defaultConfigs),
+  colorTheme$: new BehaviorSubject(defaultConfigs[FormattingOptions.ColorTheme]),
+
+  getInitialConfig(): Config {
+    return { ...this.defaultConfigs };
+  },
+
+  getFormattingOptions(): {
+    [key: string]: {
+      label: string;
+      value: Themes | number;
+    }[];
+  } {
+    return { ...this.formattingOptions };
+  },
+
+  getCodingAssistanceOptions(): { [key: string]: boolean } {
+    return { ...this.codingAssistanceOptions };
+  },
+
+  setConfig(config: Config) {
+    this.config$.next({ ...config });
+  },
+
+  getCodeComponentDestroyed(): boolean {
+    return this.codeComponentDestroyed;
+  },
+
+  setCodeComponentDestroyed(value: boolean) {
+    this.codeComponentDestroyed = value;
+  },
+};

package/src/lib/services/configurations.service.spec.ts

@@ -0,0 +1,79 @@
+import { skip } from 'rxjs';
+import { CodingAssistanceOptions, Config, FormattingOptions } from '../models/configs';
+import { Themes } from '../models/theme';
+import { ConfigurationsService } from './configurations.service';
+
+describe('ConfigurationsService', () => {
+  let service: ConfigurationsService;
+  let config: Config;
+
+  beforeEach(() => {
+    service = new ConfigurationsService();
+  });
+
+  describe('when updating the color theme', () => {
+    it('should update config$ with updated theme value', done => {
+      const theme = Themes.Dark;
+      service.config$.subscribe((val: Config) => {
+        expect(val[FormattingOptions.ColorTheme]).toEqual(theme);
+        done();
+      });
+      service.setColorTheme(theme);
+    });
+  });
+
+  describe('when config panel is opened', () => {
+    it('should publish true to configurationsPanelOpen$', done => {
+      service.configurationsPanelOpen$.subscribe(val => {
+        expect(val).toBeTruthy();
+        done();
+      });
+      service.openConfigPanel();
+    });
+  });
+
+  describe('when config panel is closed', () => {
+    it('should publish false to configurationsPanelOpen$', done => {
+      service.configurationsPanelOpen$.pipe(skip(1)).subscribe(val => {
+        expect(val).toBeFalsy();
+        done();
+      });
+      service.closeConfigPanel();
+    });
+  });
+
+  describe('when config is set', () => {
+    beforeEach(() => {
+      config = service.getInitialConfig();
+      config[FormattingOptions.ColorTheme] = Themes.Dark;
+      config[CodingAssistanceOptions.ErrorHighlighting] = false;
+    });
+    it('should publish value to config$', done => {
+      service.config$.subscribe(val => {
+        expect(val).toEqual(config);
+        done();
+      });
+      service.setConfig(config);
+    });
+    it('should publish updated theme value to colorTheme$', done => {
+      service.colorTheme$.subscribe(val => {
+        expect(val).toEqual(config[FormattingOptions.ColorTheme]);
+        done();
+      });
+      service.setConfig(config);
+    });
+  });
+
+  describe('when track config changed is called', () => {
+    it('should publish value to configFieldChanged$', done => {
+      const change = { [CodingAssistanceOptions.ErrorHighlighting]: false };
+
+      service.configFieldChanged$.subscribe(val => {
+        expect(val).toEqual(change);
+        done();
+      });
+
+      service.trackConfigChanged(change);
+    });
+  });
+});

package/src/lib/services/configurations.service.ts

@@ -0,0 +1,111 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, distinctUntilChanged, map, Observable, Subject } from 'rxjs';
+import { CodingAssistanceOptions, Config, FormattingOptions } from '../models/configs';
+import { Themes } from '../models/theme';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ConfigurationsService {
+  private defaultConfigs: Config = {
+    [FormattingOptions.ColorTheme]: Themes.Default,
+    [FormattingOptions.TabSize]: 4,
+    [FormattingOptions.FontSize]: 14,
+    [CodingAssistanceOptions.AutoComplete]: true,
+    [CodingAssistanceOptions.ErrorHighlighting]: true,
+    [CodingAssistanceOptions.AutoBrackets]: true,
+  };
+
+  private formattingOptions = {
+    [FormattingOptions.ColorTheme]: [
+      { label: 'Light', value: Themes.Default },
+      { label: 'Dark', value: Themes.Dark },
+    ],
+    [FormattingOptions.TabSize]: [
+      { label: '2', value: 2 },
+      { label: '3', value: 3 },
+      { label: '4 (default)', value: 4 },
+      { label: '5', value: 5 },
+      { label: '8', value: 8 },
+    ],
+    [FormattingOptions.FontSize]: [
+      { label: '10px', value: 10 },
+      { label: '12px', value: 12 },
+      { label: '14px (default)', value: 14 },
+      { label: '16px', value: 16 },
+      { label: '18px', value: 18 },
+      { label: '20px', value: 20 },
+    ],
+  };
+
+  private codingAssistanceOptions = {
+    [CodingAssistanceOptions.AutoComplete]: true,
+    [CodingAssistanceOptions.ErrorHighlighting]: true,
+    [CodingAssistanceOptions.AutoBrackets]: true,
+  };
+
+  private configSubj$ = new BehaviorSubject<Config>(this.defaultConfigs);
+  config$: Observable<Config> = this.configSubj$.asObservable();
+
+  private configFieldChangedSubj$ = new Subject<Partial<Config>>();
+  configFieldChanged$ = this.configFieldChangedSubj$.asObservable();
+
+  private currentConfig = { ...this.defaultConfigs };
+
+  colorTheme$: Observable<Themes> = this.config$.pipe(
+    map(config => config[FormattingOptions.ColorTheme] as Themes),
+    distinctUntilChanged()
+  );
+
+  private codeComponentDestroyed = true;
+
+  private configurationsPanelOpenSubj$ = new BehaviorSubject<boolean>(false);
+  configurationsPanelOpen$ = this.configurationsPanelOpenSubj$.asObservable();
+
+  setColorTheme(value: Themes): void {
+    this.currentConfig[FormattingOptions.ColorTheme] = value;
+    this.setConfig(this.currentConfig);
+  }
+
+  setConfig(config: Config) {
+    this.configSubj$.next(config);
+    this.currentConfig = config;
+  }
+
+  trackConfigChanged(changedField: Partial<Config>): void {
+    this.configFieldChangedSubj$.next(changedField);
+  }
+
+  getInitialConfig(): Config {
+    return { ...this.currentConfig };
+  }
+
+  openConfigPanel(): void {
+    this.configurationsPanelOpenSubj$.next(true);
+  }
+
+  closeConfigPanel() {
+    this.configurationsPanelOpenSubj$.next(false);
+  }
+
+  getFormattingOptions(): {
+    [key: string]: {
+      label: string;
+      value: Themes | number;
+    }[];
+  } {
+    return { ...this.formattingOptions };
+  }
+
+  getCodingAssistanceOptions(): { [key: string]: boolean } {
+    return { ...this.codingAssistanceOptions };
+  }
+
+  getCodeComponentDestroyed(): boolean {
+    return this.codeComponentDestroyed;
+  }
+
+  setCodeComponentDestroyed(value: boolean) {
+    this.codeComponentDestroyed = value;
+  }
+}

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

@@ -0,0 +1,265 @@
+import { TestBed } from '@angular/core/testing';
+import { MockProvider } from 'ng-mocks';
+import { Subject } from 'rxjs';
+import { CodeEditorLanguages } from '../components/code-editor/helpers/code-editor-helper.model';
+import { LanguageChangeAction } from '../models/language-change-action';
+import { Themes } from '../models/theme';
+import { ConfigurationsService } from './configurations.service';
+import { LibCodingTestService, ResetCodeAction } from './lib-coding-test.service';
+import { TestCaseDeletionAction } from '../models/test-cases';
+
+describe('LibCodingTestService', () => {
+  let service: LibCodingTestService;
+  const colorThemeSubject = new Subject<Themes>();
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        LibCodingTestService,
+        MockProvider(ConfigurationsService, {
+          colorTheme$: colorThemeSubject,
+          configFieldChanged$: new Subject(),
+        }),
+      ],
+    });
+
+    service = TestBed.inject(LibCodingTestService);
+  });
+
+  describe('when resetting the code', () => {
+    it('should publish ResetCodeAction.Try to codeReset$', done => {
+      service.codeReset$.subscribe(val => {
+        expect(val).toEqual(ResetCodeAction.Try);
+        done();
+      });
+      service.resetCode();
+    });
+  });
+
+  describe('when triggering the guided tour', () => {
+    it('should emit to startGuidedTour$', done => {
+      service.startGuidedTour$.subscribe(val => {
+        expect(val).toBeUndefined();
+        done();
+      });
+      service.startGuidedTour();
+    });
+  });
+
+  describe('when confirm resetting the code', () => {
+    it('should publish ResetCodeAction.Confirm to codeReset$', done => {
+      service.codeReset$.subscribe(val => {
+        expect(val).toEqual(ResetCodeAction.Confirm);
+        done();
+      });
+      service.confirmReset();
+    });
+  });
+
+  describe('when language change is cancelled', () => {
+    it('should publish LanguageChangeAction.Cancel to languageChange$', done => {
+      service.languageChange$.subscribe(val => {
+        expect(val).toEqual(LanguageChangeAction.Cancel);
+        done();
+      });
+      service.cancelLanguageChange();
+    });
+  });
+
+  describe('when language change is confirmed', () => {
+    it('should publish LanguageChangeAction.Confirm to languageChange$', done => {
+      service.languageChange$.subscribe(val => {
+        expect(val).toEqual(LanguageChangeAction.Confirm);
+        done();
+      });
+      service.confirmLanguageChange();
+    });
+  });
+
+  describe('when language is updated', () => {
+    it('should publish updated language to currentLanguage$', done => {
+      const language = CodeEditorLanguages.Java;
+      service.currentLanguage$.subscribe(val => {
+        expect(val).toEqual(language);
+        done();
+      });
+      service.changeCurrentLanguage(language);
+    });
+  });
+
+  describe('when handleTestCaseDeletion is called', () => {
+    it('should publish Try action to testCaseDeletionSub$', done => {
+      const index = 3;
+
+      service.testCaseDeletion$.subscribe(val => {
+        expect(val).toEqual({ action: TestCaseDeletionAction.Try, index });
+        done();
+      });
+      service.handleTestCaseDeletion(index);
+    });
+  });
+
+  describe('when confirmTestCaseDeletion is called', () => {
+    it('should publish Confirm action to testCaseDeletionSub$', done => {
+      const index = 3;
+
+      service.testCaseDeletion$.subscribe(val => {
+        expect(val).toEqual({ action: TestCaseDeletionAction.Confirm, index });
+        done();
+      });
+      service.confirmTestCaseDeletion(index);
+    });
+  });
+
+  describe('when updateTestCases is called', () => {
+    it('should set new value to testCases', () => {
+      const newTestCases = [
+        {
+          localId: 1,
+          name: 'name',
+          input: 'input',
+          expectedOutput: 'expectedOutput',
+          preloaded: false,
+        },
+      ];
+
+      service.updateTestCases(newTestCases);
+      expect(service.getTestCases()).toEqual(newTestCases);
+    });
+  });
+
+  describe('when getValidTestCases is called', () => {
+    it('should return testCases with both filled input & expectedOutput', () => {
+      const newTestCases = [
+        {
+          localId: 1,
+          name: 'name',
+          input: 'input',
+          expectedOutput: 'expectedOutput',
+          preloaded: false,
+        },
+        {
+          localId: 2,
+          name: 'name 1',
+          input: '',
+          expectedOutput: 'expectedOutput',
+          preloaded: false,
+        },
+        {
+          localId: 3,
+          name: 'name 2',
+          input: 'input',
+          expectedOutput: '',
+          preloaded: false,
+        },
+      ];
+
+      service.updateTestCases(newTestCases);
+      expect(service.getValidTestCases()).toEqual([newTestCases[0]]);
+    });
+  });
+
+  describe('when getTestCasesCount is called', () => {
+    it('should return number of all testCases', () => {
+      const newTestCases = [
+        {
+          localId: 1,
+          name: 'name',
+          input: 'input',
+          expectedOutput: 'expectedOutput',
+          preloaded: false,
+        },
+        {
+          localId: 2,
+          name: 'name 1',
+          input: '',
+          expectedOutput: 'expectedOutput',
+          preloaded: false,
+        },
+        {
+          localId: 3,
+          name: 'name 2',
+          input: 'input',
+          expectedOutput: '',
+          preloaded: false,
+        },
+      ];
+
+      service.updateTestCases(newTestCases);
+      expect(service.getTestCasesCount()).toEqual(newTestCases.length);
+    });
+  });
+
+  describe('when get/setVersion is called', () => {
+    it('should set version with passed value', () => {
+      const version = '123';
+
+      service.setVersion(version);
+      expect(service.getVersion()).toEqual(version);
+    });
+  });
+
+  describe('when get/setInitCode is called', () => {
+    it('should set initCode with passed value', () => {
+      const initCode = 'function test() { console.log(); }';
+
+      service.setInitCode(initCode);
+      expect(service.getInitCode()).toEqual(initCode);
+    });
+  });
+
+  describe('when setting fullscreen', () => {
+    it('should publish value to isFullscreen', done => {
+      const isFullscreen = true;
+
+      service.isFullscreen$.subscribe(val => {
+        expect(val).toEqual(isFullscreen);
+        done();
+      });
+      service.setFullscreen(isFullscreen);
+    });
+  });
+
+  describe('when code value is updated', () => {
+    it('should publish updated code to codeChange$', done => {
+      const code = `def lucky_8( a, b ) :
+      #Insert your code here python`;
+      service.codeChange$.subscribe(val => {
+        expect(val).toEqual(code);
+        done();
+      });
+      service.changeCurrentCode(code);
+    });
+  });
+
+  describe('when configurations color theme is updated', () => {
+    it('should publish updated theme to themeChanged$', done => {
+      const theme = Themes.Dark;
+      service.themeChanged$.subscribe(val => {
+        expect(val).toEqual(theme);
+        done();
+      });
+      colorThemeSubject.next(theme);
+    });
+  });
+
+  describe('when triggerClearSavedCode() is called', () => {
+    it('should publish to clearSavedCode$', done => {
+      service.clearSavedCode$.subscribe(val => {
+        expect(val).toEqual(true);
+        done();
+      });
+      service.triggerClearSavedCode();
+    });
+  });
+
+  describe('when setBoilerplateLoadingStatus() is called', () => {
+    it('should publish to isBoilerplateLoading$', done => {
+      service.isBoilerplateLoading$.subscribe(val => {
+        expect(val).toEqual(false);
+        done();
+      });
+      service.setBoilerplateLoadingStatus(false);
+    });
+  });
+});