@testgorilla/tgo-coding-test 1.0.0 → 2.0.0

package/src/lib/components/code-editor/code-editor.component.ts

@@ -0,0 +1,368 @@
+import {
+  ChangeDetectionStrategy,
+  ChangeDetectorRef,
+  Component,
+  ElementRef,
+  EventEmitter,
+  inject,
+  Input,
+  OnChanges,
+  OnDestroy,
+  OnInit,
+  Output,
+  SimpleChanges,
+  ViewChild,
+} from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';
+import { editor, IDisposable } from 'monaco-editor';
+import { combineLatest, distinctUntilChanged, filter, first, interval, map, take } from 'rxjs';
+import { MonacoEditorModule } from 'ngx-monaco-editor-v2';
+
+import { erlangLanguage } from '../../utils/additional-languages/erlang';
+import { CodingAssistanceOptions, Config, FormattingOptions } from '../../models/configs';
+import { Themes } from '../../models/theme';
+import { ConfigurationsService } from '../../services/configurations.service';
+import { LibCodingTestService, ResetCodeAction } from '../../services/lib-coding-test.service';
+import { StorageCodingService } from '../../services/storage.service';
+import { CodeEditorService } from './code-editor.service';
+import { CodeEditorFuncParam, CodeEditorLanguages, CodeEditorTypesMap } from './helpers/code-editor-helper.model';
+import { MonacoColorTheme, PasteData } from './models/code-editor.model';
+import { CodingSnapshot } from './models/coding-snapshot.model';
+
+@UntilDestroy()
+@Component({
+    selector: 'tgo-code-editor',
+    templateUrl: './code-editor.component.html',
+    styleUrls: ['./code-editor.component.scss'],
+    changeDetection: ChangeDetectionStrategy.OnPush,
+    imports: [CommonModule, FormsModule, MonacoEditorModule]
+})
+export class CodeEditorComponent implements OnInit, OnDestroy, OnChanges {
+  private readonly libCodingTestService = inject(LibCodingTestService);
+  private readonly configurationsService = inject(ConfigurationsService);
+  private readonly codeEditorService = inject(CodeEditorService);
+  private readonly changeDetectorRef = inject(ChangeDetectorRef);
+  private readonly StorageCodingService = inject(StorageCodingService);
+
+  @Input() initCode: string;
+  @Input() functionParams: CodeEditorFuncParam[];
+  @Input() functionName: string;
+  @Input() returnType: keyof CodeEditorTypesMap;
+  @Input() hasCodingConfigPanel: boolean;
+  @Input() isReadonly: boolean;
+  @Input() autoHeight: boolean;
+  @Input() shouldGenerateInitCode: boolean;
+
+  @Input() set snapshot(snap: CodingSnapshot) {
+    if (snap) {
+      this.currentSnapshot = snap;
+      this.handleSnapshot(snap.text);
+    }
+  }
+
+  @Output() pasteEvent = new EventEmitter<PasteData>();
+  @Output() codeChange = new EventEmitter<string>();
+
+  @ViewChild('editor', { read: ElementRef }) codeEditorElRef: ElementRef;
+
+  code = '';
+  codePublished = '';
+  codeLanguage = '';
+  editorOptions: { [key: string]: any } = {
+    theme: MonacoColorTheme.Dark,
+    fontSize: '14',
+    scrollBeyondLastLine: false,
+    minimap: { enabled: false },
+    fixedOverflowWidgets: true,
+    insertSpaces: false,
+    detectIndentation: false,
+    automaticLayout: true,
+  };
+
+  editor: editor.ICodeEditor;
+  previousConfig = this.StorageCodingService.getSavedConfig();
+
+  currentSnapshot: CodingSnapshot;
+  previousMonacoDecoration: editor.IEditorDecorationsCollection;
+
+  private pasteListener: IDisposable;
+  private contentChangedSub: IDisposable;
+
+  ngOnInit(): void {
+    if (!this.previousConfig) {
+      this.previousConfig = this.configurationsService.getInitialConfig();
+    }
+
+    if (this.hasCodingConfigPanel) {
+      this.updateIDEConfig();
+    }
+    this.listenUpdates();
+
+    this.setupConfigs();
+    this.setupCode();
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    if (typeof changes.initCode?.currentValue === 'string') {
+      this.code = changes.initCode.currentValue;
+    }
+  }
+
+  ngOnDestroy(): void {
+    this.contentChangedSub?.dispose();
+    this.pasteListener?.dispose();
+  }
+
+  initEditor(editor: editor.ICodeEditor): void {
+    this.editor = editor;
+
+    this.pasteListener = this.editor.onDidPaste(event => this.catchEvent(event));
+
+    if (this.currentSnapshot) {
+      this.handleSnapshot(this.currentSnapshot.text);
+    }
+
+    if (this.autoHeight) {
+      this.listenContentHeight(editor);
+    }
+  }
+
+  private catchEvent(event: editor.IPasteEvent): void {
+    const data = this.editor.getModel()?.getValueInRange(event.range);
+    if (data) {
+      this.pasteEvent.emit({ type: 'paste', data });
+    }
+  }
+
+  publishCode(code): void {
+    if (code !== this.codePublished) {
+      this.codePublished = code;
+      this.codeChange.emit(this.codePublished);
+    }
+  }
+
+  private updateIDEConfig(): void {
+    this.configurationsService.config$
+      .pipe(distinctUntilChanged(), untilDestroyed(this))
+      .subscribe((config: Config) => {
+        let configObject = {};
+        // eslint-disable-next-line guard-for-in
+        for (const key in config) {
+          if (config[key] !== this.previousConfig[key]) {
+            switch (key as FormattingOptions | CodingAssistanceOptions) {
+              case FormattingOptions.ColorTheme:
+                configObject = {
+                  theme:
+                    config[FormattingOptions.ColorTheme] === Themes.Default
+                      ? MonacoColorTheme.Light
+                      : MonacoColorTheme.Dark,
+                };
+
+                break;
+              case CodingAssistanceOptions.AutoComplete:
+                configObject = {
+                  quickSuggestions: {
+                    other: config[CodingAssistanceOptions.AutoComplete],
+                  },
+                };
+
+                break;
+              case CodingAssistanceOptions.AutoBrackets:
+                configObject = {
+                  autoClosingBrackets: config[CodingAssistanceOptions.AutoBrackets] ? 'always' : 'never',
+                };
+
+                break;
+              case FormattingOptions.TabSize:
+                configObject = {
+                  tabSize: config[FormattingOptions.TabSize],
+                };
+
+                break;
+              case FormattingOptions.FontSize:
+                configObject = {
+                  fontSize: config[FormattingOptions.FontSize],
+                };
+
+                break;
+              case CodingAssistanceOptions.ErrorHighlighting:
+                this.libCodingTestService.currentLanguage$.pipe(take(1)).subscribe(language => {
+                  if (language === CodeEditorLanguages.Javascript) {
+                    window['monaco'].languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+                      noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+                      noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+                    });
+                  } else if (language === CodeEditorLanguages.Typescript) {
+                    window['monaco'].languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+                      noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+                      noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+                    });
+                  }
+                });
+                break;
+            }
+            this.editorOptions = Object.assign({}, this.editorOptions, configObject);
+          }
+        }
+        this.changeDetectorRef.detectChanges();
+        this.previousConfig = config;
+      });
+
+    this.editorOptions = Object.assign({}, this.editorOptions, {
+      automaticLayout: true,
+    });
+  }
+
+  private listenContentHeight(editor: editor.ICodeEditor): void {
+    const updateHeight = () => {
+      window.requestAnimationFrame(() => {
+        const { width } = this.codeEditorElRef.nativeElement.getBoundingClientRect();
+        const contentHeight = Math.min(1000, editor.getContentHeight());
+        this.codeEditorElRef.nativeElement.style.height = `${contentHeight}px`;
+        editor.layout({ width, height: contentHeight });
+      });
+    };
+
+    this.contentChangedSub = editor.onDidContentSizeChange(updateHeight);
+    updateHeight();
+  }
+
+  private setupConfigs(): void {
+    const { functionParams: params, functionName: name, returnType } = this;
+
+    const config = this.previousConfig;
+
+    const wordWrap = this.currentSnapshot ? 'on' : 'off';
+    const theme = this.getInitialColorTheme(config, this.currentSnapshot);
+
+    this.libCodingTestService.currentLanguage$.pipe(untilDestroyed(this)).subscribe((language: CodeEditorLanguages) => {
+      if (this.shouldGenerateInitCode) {
+        this.codeEditorService.setHelper(language, { params, name, returnType });
+        this.codeLanguage = this.codeEditorService.getEditorLang();
+      } else {
+        if (language === CodeEditorLanguages.Cpp) {
+          this.codeLanguage = CodeEditorLanguages.CppEditor;
+        } else if (language === CodeEditorLanguages.CSharp || language === CodeEditorLanguages.CSharpLegacy) {
+          this.codeLanguage = CodeEditorLanguages.CSharpEditor;
+        } else if (language === CodeEditorLanguages.Sqlite) {
+          this.codeLanguage = CodeEditorLanguages.Sql;
+        } else {
+          this.codeLanguage = language;
+        }
+      }
+      this.editorOptions = Object.assign({}, this.editorOptions, {
+        language: this.codeLanguage,
+      });
+    });
+
+    this.editorOptions = Object.assign({}, this.editorOptions, {
+      readOnly: this.isReadonly,
+      quickSuggestions: {
+        other: config[CodingAssistanceOptions.AutoComplete],
+      },
+      autoClosingBrackets: config[CodingAssistanceOptions.AutoBrackets] ? 'always' : 'never',
+      tabSize: config[FormattingOptions.TabSize],
+      fontSize: config[FormattingOptions.FontSize],
+      theme,
+      wordWrap,
+    });
+    const monacoLibraryReady$ = interval(100).pipe(
+      map(() => window.monaco),
+      filter(Boolean),
+      first()
+    );
+    combineLatest({
+      monaco: monacoLibraryReady$,
+      language: this.libCodingTestService.currentLanguage$,
+    })
+      .pipe(take(1))
+      .subscribe(result => {
+        if (result.language === CodeEditorLanguages.Javascript) {
+          result.monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+            noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+            noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+          });
+        } else if (result.language === CodeEditorLanguages.Typescript) {
+          result.monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+            noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+            noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],
+          });
+        }
+        result.monaco.languages.register({ id: CodeEditorLanguages.Erlang });
+        result.monaco.languages.setMonarchTokensProvider(CodeEditorLanguages.Erlang, erlangLanguage);
+      });
+  }
+
+  private getInitialColorTheme(config: Config, snapshot: CodingSnapshot): string {
+    let theme: MonacoColorTheme;
+
+    if (snapshot) {
+      theme = MonacoColorTheme.Dark;
+    } else {
+      theme = config[FormattingOptions.ColorTheme] === Themes.Default ? MonacoColorTheme.Light : MonacoColorTheme.Dark;
+    }
+
+    return theme;
+  }
+
+  private setupCode(calledFromReset = false) {
+    this.handleInitCode(calledFromReset);
+    this.publishCode(this.code);
+  }
+
+  private handleInitCode(calledFromReset = false): void {
+    if (calledFromReset) {
+      this.code = this.libCodingTestService.getInitCode();
+    } else if (this.initCode) {
+      this.code = this.initCode;
+    } else if (this.currentSnapshot) {
+      return;
+    } else if (this.shouldGenerateInitCode) {
+      this.code = this.codeEditorService.getInitCode();
+    }
+  }
+
+  private listenUpdates(): void {
+    this.libCodingTestService.codeReset$
+      .pipe(
+        filter(val => val === ResetCodeAction.Confirm),
+        untilDestroyed(this)
+      )
+      .subscribe(() => {
+        this.setupCode(true);
+      });
+  }
+
+  private handleSnapshot(code: string): void {
+    this.code = code;
+
+    if (!this.editor) {
+      return;
+    }
+
+    this.editor.setValue(code); // make sure editor model has the latest value of the code
+
+    if (this.previousMonacoDecoration) {
+      this.previousMonacoDecoration.clear();
+    }
+
+    if (this.currentSnapshot.copied_text) {
+      // if the snapshot contains copyPasted code, find it's range in monaco
+      const matches = this.editor
+        .getModel()
+        .findMatches(this.currentSnapshot.copied_text, false, false, true, null, true);
+
+      if (matches.length) {
+        // if the range is found in editor model, decorate it with additional class to highlight on the ui
+        this.previousMonacoDecoration = this.editor.createDecorationsCollection([
+          {
+            range: matches[0].range,
+            options: { inlineClassName: 'copy-pasted-code' },
+          },
+        ]);
+      }
+    }
+  }
+}

package/src/lib/components/code-editor/code-editor.mocks.ts

@@ -0,0 +1,28 @@
+import { CodeEditorFuncParam } from './helpers/code-editor-helper.model';
+import { editor } from 'monaco-editor';
+
+export const functionParamsMock: CodeEditorFuncParam[] = [
+  {
+    name: 'param1',
+    type: 'boolean',
+  },
+  {
+    name: 'param2',
+    type: 'int',
+  },
+];
+
+export const initCodeMock = 'export function mock(param1, param2) { return param1; }';
+
+export const editorMock = {
+  onDidPaste: () => ({
+    dispose: () => {
+      // Mock implementation - no-op
+    },
+  }),
+} as unknown as editor.ICodeEditor;
+
+export const pasteEventMock = {
+  type: 'paste',
+  data: 'text',
+};

package/src/lib/components/code-editor/code-editor.service.spec.ts

@@ -0,0 +1,160 @@
+import { functionParamsMock } from './code-editor.mocks';
+import { CodeEditorService } from './code-editor.service';
+import { CodeEditorJavascriptHelper } from './helpers';
+import { CodeEditorFuncOptions, CodeEditorLanguages } from './helpers/code-editor-helper.model';
+
+describe('CodeEditorService', () => {
+  let service: CodeEditorService;
+
+  const defaultLang = CodeEditorLanguages.Javascript;
+  const defaultParams: CodeEditorFuncOptions = {
+    params: [...functionParamsMock],
+    name: 'mockFunction',
+    returnType: 'boolean',
+  };
+  const jsHelper = new CodeEditorJavascriptHelper(defaultParams);
+
+  beforeEach(() => {
+    service = new CodeEditorService();
+    service.setHelper(defaultLang, defaultParams);
+  });
+
+  describe('when setting helper', () => {
+    describe('and passing Javascript', () => {
+      it('should create helper for corresponding language', () => {
+        expect(service.getEditorLang()).toEqual(defaultLang);
+      });
+    });
+
+    describe('and passing Typescript', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Typescript, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Typescript);
+      });
+    });
+
+    describe('and passing Php', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Php, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Php);
+      });
+    });
+
+    describe('and passing Python', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Python, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Python);
+      });
+    });
+
+    describe('and passing Java', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Java, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Java);
+      });
+    });
+
+    describe('and passing Ruby', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Ruby, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Ruby);
+      });
+    });
+
+    describe('and passing C', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.C, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.C);
+      });
+    });
+
+    describe('and passing C++', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Cpp, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.CppEditor);
+      });
+    });
+
+    describe('and passing R', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.R, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.R);
+      });
+    });
+
+    describe('and passing Scala', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Scala, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Scala);
+      });
+    });
+
+    describe('and passing C#', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.CSharp, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.CSharpEditor);
+      });
+    });
+
+    describe('and passing C#_legacy', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.CSharpLegacy, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.CSharpEditor);
+      });
+    });
+
+    describe('and passing Go', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Go, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Go);
+      });
+    });
+
+    describe('and passing SQL', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(CodeEditorLanguages.Sql, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Sql);
+      });
+    });
+
+    describe('and passing sqlite3', () => {
+      it('should create helper for SQL language', () => {
+        service.setHelper(CodeEditorLanguages.Sqlite, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Sql);
+      });
+    });
+
+    describe('and passing Kotlin', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(`${CodeEditorLanguages.Kotlin}_1.10`, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Kotlin);
+      });
+    });
+
+    describe('and passing Swift', () => {
+      it('should create helper for corresponding language', () => {
+        service.setHelper(`${CodeEditorLanguages.Swift}_1.10`, defaultParams);
+        expect(service.getEditorLang()).toEqual(CodeEditorLanguages.Swift);
+      });
+    });
+
+    describe('and passing unknown language', () => {
+      it('should throw an error', () => {
+        const randomLang = 'randomLang';
+        try {
+          service.setHelper(randomLang, defaultParams);
+        } catch (e) {
+          expect(e.message).toEqual(`language ${randomLang} is not supported`);
+        }
+      });
+    });
+  });
+
+  describe('when getting init code', () => {
+    it('should return init code', () => {
+      const result = service.getInitCode();
+
+      expect(result).toEqual(jsHelper.getInitCode());
+    });
+  });
+});

package/src/lib/components/code-editor/code-editor.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import {
+  CodeEditorCHelper,
+  CodeEditorCppHelper,
+  CodeEditorCSharpHelper,
+  CodeEditorGoHelper,
+  CodeEditorJavaHelper,
+  CodeEditorJavascriptHelper,
+  CodeEditorKotlinHelper,
+  CodeEditorPhpHelper,
+  CodeEditorPythonHelper,
+  CodeEditorRHelper,
+  CodeEditorRubyHelper,
+  CodeEditorScalaHelper,
+  CodeEditorSqlHelper,
+  CodeEditorSwiftHelper,
+  CodeEditorTypescriptHelper,
+} from './helpers';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+} from './helpers/code-editor-helper.model';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CodeEditorService {
+  private helper: CodeEditorHelper;
+
+  setHelper(language: string, funcParams: CodeEditorFuncOptions): void {
+    this.helper = this.createHelper(language, funcParams);
+  }
+
+  getInitCode(): string {
+    return this.helper.getInitCode();
+  }
+
+  getEditorLang(): string {
+    return this.helper.getEditorLang();
+  }
+
+  private createHelper(lang: string, funcParams: CodeEditorFuncOptions): CodeEditorHelper {
+    // todo: review this logic according to new TAT, remove generated init code if not needed ?
+    switch (lang as CodeEditorLanguages) {
+      case CodeEditorLanguages.Javascript:
+        return new CodeEditorJavascriptHelper(funcParams);
+      case CodeEditorLanguages.Typescript:
+        return new CodeEditorTypescriptHelper(funcParams);
+      case CodeEditorLanguages.Php:
+        return new CodeEditorPhpHelper(funcParams);
+      case CodeEditorLanguages.Python:
+        return new CodeEditorPythonHelper(funcParams);
+      case CodeEditorLanguages.Java:
+        return new CodeEditorJavaHelper(funcParams);
+      case CodeEditorLanguages.Ruby:
+        return new CodeEditorRubyHelper(funcParams);
+      case CodeEditorLanguages.C:
+        return new CodeEditorCHelper(funcParams);
+      case CodeEditorLanguages.Cpp:
+        return new CodeEditorCppHelper(funcParams);
+      case CodeEditorLanguages.R:
+        return new CodeEditorRHelper(funcParams);
+      case CodeEditorLanguages.Scala:
+        return new CodeEditorScalaHelper(funcParams);
+      case CodeEditorLanguages.CSharp:
+      case CodeEditorLanguages.CSharpLegacy:
+        return new CodeEditorCSharpHelper(funcParams);
+      case CodeEditorLanguages.Go:
+        return new CodeEditorGoHelper(funcParams);
+      case CodeEditorLanguages.Sql:
+      case CodeEditorLanguages.Sqlite:
+        return new CodeEditorSqlHelper(funcParams);
+      default: {
+        const versionedHelper = lang && this.getVersionedHelper(lang, funcParams);
+
+        if (!versionedHelper) {
+          throw new Error(`language ${lang} is not supported`);
+        }
+
+        return versionedHelper;
+      }
+    }
+  }
+
+  private getVersionedHelper(lang: string, funcParams: CodeEditorFuncOptions): CodeEditorHelper {
+    if (lang.startsWith(CodeEditorLanguages.Kotlin)) {
+      return new CodeEditorKotlinHelper(funcParams);
+    }
+    if (lang.startsWith(CodeEditorLanguages.Swift)) {
+      return new CodeEditorSwiftHelper(funcParams);
+    }
+  }
+}

package/src/lib/components/code-editor/helpers/c-helper.spec.ts

@@ -0,0 +1,39 @@
+import { CodeEditorCHelper } from './c-helper';
+import { defaultFuncParams } from './code-editor-helper.mocks';
+
+describe('CodeEditorCHelper', () => {
+  let helper: CodeEditorCHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const correctFuncOpening =
+    'bool mockFunction(bool param1, int param2, double param3, float param4, char * param5, bool * param6, int * param7, float * param8) {\n';
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorCHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});