@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

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

@@ -1,160 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

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

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

@@ -1,51 +0,0 @@
-import { CodeEditorHelperBase } from './code-editor-helper.base';
-import {
-  CodeEditorFuncOptions,
-  CodeEditorHelper,
-  CodeEditorLanguages,
-  CodeEditorTypesMap,
-} from './code-editor-helper.model';
-
-export class CodeEditorCHelper extends CodeEditorHelperBase implements CodeEditorHelper {
-  language = CodeEditorLanguages.C;
-  typesMap: CodeEditorTypesMap = {
-    boolean: 'bool',
-    int: 'int',
-    number: 'int',
-    double: 'double',
-    float: 'float',
-    str: 'char *',
-    array_boolean: 'bool *',
-    array_int: 'int *',
-    array_float: 'float *',
-    array_double: 'double *',
-  };
-
-  constructor(private functionOptions: CodeEditorFuncOptions) {
-    super();
-  }
-
-  getInitCode(): string {
-    return `${this.getFunctionOpening()}\t //Insert your code here \n}`;
-  }
-
-  getFunctionOpening(): string {
-    const { name: funcName, returnType } = this.functionOptions;
-    const params = this.getParamsString();
-    const showingReturnType = this.parseType(returnType);
-
-    return `${showingReturnType} ${funcName}(${params}) {\n`;
-  }
-
-  private getParamsString(): string {
-    const { params } = this.functionOptions;
-    let paramsString = '';
-
-    if (params && params.length > 0) {
-      params.forEach(values => (paramsString += `${this.parseType(values.type)} ${values.name}, `));
-      paramsString = paramsString.slice(0, -2);
-    }
-
-    return paramsString;
-  }
-}

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

@@ -1,30 +0,0 @@
-import { CodeEditorHelperBase } from './code-editor-helper.base';
-import { CodeEditorLanguages } from './code-editor-helper.model';
-
-class Helper extends CodeEditorHelperBase {
-  language = CodeEditorLanguages.Javascript;
-
-  getFunctionOpening(): string {
-    return 'func opening\n';
-  }
-}
-
-describe('CodeEditorHelperBase', () => {
-  let helper: Helper;
-
-  beforeEach(() => {
-    helper = new Helper();
-  });
-
-  describe('when getting editor language', () => {
-    let result: string;
-
-    beforeEach(() => {
-      result = helper.getEditorLang();
-    });
-
-    it('should return helper language', () => {
-      expect(result).toEqual(CodeEditorLanguages.Javascript);
-    });
-  });
-});

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

@@ -1,16 +0,0 @@
-import { CodeEditorLanguages, CodeEditorTypesMap } from './code-editor-helper.model';
-
-export abstract class CodeEditorHelperBase {
-  protected language: CodeEditorLanguages;
-  protected typesMap: CodeEditorTypesMap;
-
-  abstract getFunctionOpening(): string;
-
-  getEditorLang(): CodeEditorLanguages {
-    return this.language;
-  }
-
-  protected parseType(type: keyof CodeEditorTypesMap): string {
-    return this.typesMap[type];
-  }
-}

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

@@ -1,24 +0,0 @@
-import { CodeEditorFuncOptions } from './code-editor-helper.model';
-
-export const initCodeMock = 'export function mock(param1, param2) { return param1; }';
-
-export const defaultFuncParams: CodeEditorFuncOptions = {
-  params: [
-    {
-      name: 'param1',
-      type: 'boolean',
-    },
-    {
-      name: 'param2',
-      type: 'int',
-    },
-    { name: 'param3', type: 'double' },
-    { name: 'param4', type: 'float' },
-    { name: 'param5', type: 'str' },
-    { name: 'param6', type: 'array_boolean' },
-    { name: 'param7', type: 'array_int' },
-    { name: 'param8', type: 'array_float' },
-  ],
-  name: 'mockFunction',
-  returnType: 'boolean',
-};

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

@@ -1,67 +0,0 @@
-export interface CodeEditorHelper {
-  getInitCode?(): string;
-  getEditorLang(): string;
-}
-
-export const enum CodeEditorLanguages {
-  Javascript = 'javascript',
-  Typescript = 'typescript',
-  Elixir = 'elixir',
-  Rust = 'rust',
-  Dart = 'dart',
-  Erlang = 'erlang',
-  Julia = 'julia',
-  Perl = 'perl',
-  Php = 'php',
-  Python = 'python',
-  Java = 'java',
-  Kotlin = 'kotlin',
-  Ruby = 'ruby',
-  C = 'c',
-  Cpp = 'c++',
-  CppEditor = 'cpp',
-  R = 'r',
-  Swift = 'swift',
-  Scala = 'scala',
-  CSharp = 'c#',
-  CSharpEditor = 'csharp',
-  CSharpLegacy = 'c#_legacy',
-  Go = 'go',
-  Sql = 'sql',
-  Sqlite = 'sqlite3',
-}
-
-export const enum CodeEditorSqlOperations {
-  Select = 'SELECT',
-  Update = 'UPDATE',
-  Insert = 'INSERT',
-  Delete = 'DELETE',
-  CreateTable = 'CREATE TABLE',
-}
-
-export interface CodeEditorFuncOptions {
-  name?: string | CodeEditorSqlOperations;
-  params?: CodeEditorFuncParam[];
-  returnType?: keyof CodeEditorTypesMap;
-}
-
-export interface CodeEditorFuncParam {
-  id?: string;
-  name?: string;
-  order?: string;
-  type?: keyof CodeEditorTypesMap;
-}
-
-export interface CodeEditorTypesMap {
-  boolean: string;
-  int: string;
-  number?: string;
-  double: string;
-  float: string;
-  str: string;
-  array_boolean: string;
-  array_int: string;
-  array_float: string;
-  array_double?: string;
-  array_str?: string;
-}

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

@@ -1,40 +0,0 @@
-import { defaultFuncParams } from './code-editor-helper.mocks';
-import { CodeEditorCppHelper } from './cpp-helper';
-
-describe('CodeEditorCppHelper', () => {
-  let helper: CodeEditorCppHelper;
-
-  const defaultParams = { ...defaultFuncParams };
-  const paramsList =
-    'bool param1, int param2, double param3, float param4, std::string param5, std::vector<bool> param6, std::vector<int> param7, std::vector<float> param8';
-  const correctFuncOpening = `bool mockFunction(${paramsList}) {\n`;
-  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
-
-  beforeEach(() => {
-    helper = new CodeEditorCppHelper(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);
-    });
-  });
-});

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

@@ -1,52 +0,0 @@
-import { CodeEditorHelperBase } from './code-editor-helper.base';
-import {
-  CodeEditorFuncOptions,
-  CodeEditorHelper,
-  CodeEditorLanguages,
-  CodeEditorTypesMap,
-} from './code-editor-helper.model';
-
-export class CodeEditorCppHelper extends CodeEditorHelperBase implements CodeEditorHelper {
-  language = CodeEditorLanguages.CppEditor;
-  typesMap: CodeEditorTypesMap = {
-    boolean: 'bool',
-    int: 'int',
-    number: 'int',
-    double: 'double',
-    float: 'float',
-    str: 'std::string',
-    array_boolean: 'std::vector<bool>',
-    array_int: 'std::vector<int>',
-    array_float: 'std::vector<float>',
-    array_double: 'std::vector<double>',
-    array_str: 'std::vector<std::string>',
-  };
-
-  constructor(private functionOptions: CodeEditorFuncOptions) {
-    super();
-  }
-
-  getInitCode(): string {
-    return `${this.getFunctionOpening()}\t //Insert your code here \n}`;
-  }
-
-  getFunctionOpening(): string {
-    const { name: funcName, returnType } = this.functionOptions;
-    const params = this.getParamsString();
-    const showingReturnType = this.parseType(returnType);
-
-    return `${showingReturnType} ${funcName}(${params}) {\n`;
-  }
-
-  private getParamsString(): string {
-    const { params } = this.functionOptions;
-    let paramsString = '';
-
-    if (params && params.length > 0) {
-      params.forEach(values => (paramsString += `${this.parseType(values.type)} ${values.name}, `));
-      paramsString = paramsString.slice(0, -2);
-    }
-
-    return paramsString;
-  }
-}

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

@@ -1,42 +0,0 @@
-import { defaultFuncParams } from './code-editor-helper.mocks';
-import { CodeEditorCSharpHelper } from './csharp-helper';
-
-describe('CodeEditorCSharpHelper', () => {
-  let helper: CodeEditorCSharpHelper;
-
-  const defaultParams = { ...defaultFuncParams };
-  const paramsList =
-    'bool param1, int param2, double param3, float param4, string param5, bool[] param6, int[] param7, Float[] param8';
-  const correctFuncOpening = `\t\tpublic static bool mockFunction(${paramsList}) {\n`;
-  const importText =
-    'using System;\nusing System.Linq;\nnamespace TestTaker\n{\n\tpublic static class CustomCode\n\t{\n';
-  const correctInitCode = `${importText}${correctFuncOpening}\t\t //Insert your code here \n\t\t}\n\t}\n}`;
-
-  beforeEach(() => {
-    helper = new CodeEditorCSharpHelper(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);
-    });
-  });
-});

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

@@ -1,55 +0,0 @@
-import { CodeEditorHelperBase } from './code-editor-helper.base';
-import {
-  CodeEditorFuncOptions,
-  CodeEditorHelper,
-  CodeEditorLanguages,
-  CodeEditorTypesMap,
-} from './code-editor-helper.model';
-
-export class CodeEditorCSharpHelper extends CodeEditorHelperBase implements CodeEditorHelper {
-  language = CodeEditorLanguages.CSharpEditor;
-  typesMap: CodeEditorTypesMap = {
-    boolean: 'bool',
-    int: 'int',
-    number: 'int',
-    double: 'double',
-    float: 'float',
-    str: 'string',
-    array_boolean: 'bool[]',
-    array_int: 'int[]',
-    array_float: 'Float[]',
-    array_double: 'double[]',
-    array_str: 'string[]',
-  };
-
-  private importText =
-    'using System;\nusing System.Linq;\nnamespace TestTaker\n{\n\tpublic static class CustomCode\n\t{\n';
-
-  constructor(private functionOptions: CodeEditorFuncOptions) {
-    super();
-  }
-
-  getInitCode(): string {
-    return `${this.importText}${this.getFunctionOpening()}\t\t //Insert your code here \n\t\t}\n\t}\n}`;
-  }
-
-  getFunctionOpening(): string {
-    const { name: funcName, returnType } = this.functionOptions;
-    const params = this.getParamsString();
-    const showingReturnType = this.parseType(returnType);
-
-    return `\t\tpublic static ${showingReturnType} ${funcName}(${params}) {\n`;
-  }
-
-  private getParamsString(): string {
-    const { params } = this.functionOptions;
-    let paramsString = '';
-
-    if (params && params.length > 0) {
-      params.forEach(values => (paramsString += `${this.parseType(values.type)} ${values.name}, `));
-      paramsString = paramsString.slice(0, -2);
-    }
-
-    return paramsString;
-  }
-}