@testgorilla/tgo-coding-test 1.0.0 → 2.0.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorGoHelper } from './go-helper';
+
+describe('CodeEditorGoHelper', () => {
+  let helper: CodeEditorGoHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'param1 bool, param2 int, param3 double, param4 float64, param5 string, param6 []bool, param7 []int, param8 []float64';
+  const correctFuncOpening = `func MockFunction(${paramsList}) bool {\n`;
+  const importPackagesText = 'package testtaker\nimport ()\n';
+  const correctInitCode = `${importPackagesText}${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorGoHelper(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/go-helper.ts

@@ -0,0 +1,54 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorGoHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Go;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'bool',
+    int: 'int',
+    number: 'int',
+    double: 'double',
+    float: 'float64',
+    str: 'string',
+    array_boolean: '[]bool',
+    array_int: '[]int',
+    array_float: '[]float64',
+    array_str: '[]string',
+  };
+
+  private importPackagesText = 'package testtaker\nimport ()\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.importPackagesText}${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);
+    const uppercasedFuncName = `${funcName.charAt(0).toUpperCase()}${funcName.slice(1)}`;
+
+    return `func ${uppercasedFuncName}(${params}) ${showingReturnType} {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name} ${this.parseType(values.type)}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

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

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorJavaHelper } from './java-helper';
+
+describe('CodeEditorJavaHelper', () => {
+  let helper: CodeEditorJavaHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'Boolean param1, Integer param2, Double param3, Float param4, String param5, Boolean[] param6, Integer[] param7, Float[] param8';
+  const classOpening = 'public class TestTaker {\n';
+  const correctFuncOpening = `\tpublic static Boolean mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${classOpening}${correctFuncOpening}\t\t //Insert your code here \n\t}\n`;
+
+  beforeEach(() => {
+    helper = new CodeEditorJavaHelper(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/java-helper.ts

@@ -0,0 +1,54 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorJavaHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Java;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Integer',
+    number: 'Integer',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Boolean[]',
+    array_int: 'Integer[]',
+    array_float: 'Float[]',
+    array_double: 'Double[]',
+    array_str: 'String[]',
+  };
+
+  private classOpening = 'public class TestTaker {\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.classOpening}${this.getFunctionOpening()}\t\t //Insert your code here \n\t}\n`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName, returnType } = this.functionOptions;
+    const params = this.getParamsString();
+    const showingReturnType = this.parseType(returnType);
+
+    return `\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;
+  }
+}

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

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorJavascriptHelper } from './javascript-helper';
+
+describe('CodeEditorJavascriptHelper', () => {
+  let helper: CodeEditorJavascriptHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = 'param1, param2, param3, param4, param5, param6, param7, param8';
+  const correctFuncOpening = `export function mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorJavascriptHelper(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/javascript-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorJavascriptHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Javascript;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t //Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `export function ${funcName}(${this.getParamsString()}) {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

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

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorKotlinHelper } from './kotlin-helper';
+
+describe('CodeEditorKotlinHelper', () => {
+  let helper: CodeEditorKotlinHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'param1: Boolean, param2: Int, param3: Double, param4: Float, param5: String, param6: Array<Boolean>, param7: Array<Int>, param8: Array<Float>';
+  const packages = 'package com.testgorilla.testtaker\n';
+  const correctFuncOpening = `fun mockFunction(${paramsList}): Boolean {\n`;
+  const correctInitCode = `${packages}${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorKotlinHelper(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);
+    });
+  });
+});