@testgorilla/tgo-coding-test 1.0.0 → 2.0.0

package/src/lib/components/code-editor/helpers/kotlin-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 CodeEditorKotlinHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Kotlin;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Int',
+    number: 'int',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Array<Boolean>',
+    array_int: 'Array<Int>',
+    array_float: 'Array<Float>',
+    array_double: 'Array<Double>',
+    array_str: 'Array<String>',
+  };
+
+  private packagesText = 'package com.testgorilla.testtaker\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.packagesText}${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 `fun ${funcName}(${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/php-helper.spec.ts

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

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorPhpHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Php;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t //Insert your code here \n}\n ?>`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `<?php 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/python-helper.spec.ts

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

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorPythonHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Python;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \n`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `def ${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/r-helper.spec.ts

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

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorRHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.R;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `${funcName} <- function(${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/ruby-helper.spec.ts

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

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorRubyHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Ruby;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \nend`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `def ${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/scala-helper.spec.ts

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

@@ -0,0 +1,53 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorScalaHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Scala;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Int',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Array[Boolean]',
+    array_int: 'Array[Integer]',
+    array_float: 'Array[Float]',
+    array_double: 'Array[Double]',
+    array_str: 'Array[String]',
+  };
+
+  private packagesText = 'package Testgorilla\nobject TestTaker\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.packagesText}${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 `def ${funcName}(${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/sql-helper.spec.ts

@@ -0,0 +1,87 @@
+import { CodeEditorFuncOptions, CodeEditorSqlOperations } from './code-editor-helper.model';
+import { CodeEditorSqlHelper } from './sql-helper';
+
+describe('CodeEditorSqlHelper', () => {
+  let helper: CodeEditorSqlHelper;
+
+  const defaultParams: CodeEditorFuncOptions = { name: CodeEditorSqlOperations.Select };
+  const correctFuncOpening = 'SELECT\n';
+  const correctSelectInitCode = `${correctFuncOpening}## FROM ## WHERE ##;\n`;
+
+  beforeEach(() => {
+    helper = new CodeEditorSqlHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    describe('and operation is SELECT', () => {
+      it('should return proper init code', () => {
+        expect(result).toEqual(correctSelectInitCode);
+      });
+    });
+
+    describe('and operation is UPDATE', () => {
+      it('should return proper init code', () => {
+        const correctInitCode = 'UPDATE\n## SET ## WHERE ##;\n';
+        helper = new CodeEditorSqlHelper({ name: CodeEditorSqlOperations.Update });
+        result = helper.getInitCode();
+        expect(result).toEqual(correctInitCode);
+      });
+    });
+
+    describe('and operation is INSERT', () => {
+      it('should return proper init code', () => {
+        const correctInitCode = 'INSERT\nINTO ## WHERE ##;\n';
+        helper = new CodeEditorSqlHelper({ name: CodeEditorSqlOperations.Insert });
+        result = helper.getInitCode();
+        expect(result).toEqual(correctInitCode);
+      });
+    });
+
+    describe('and operation is DELETE', () => {
+      it('should return proper init code', () => {
+        const correctInitCode = 'DELETE\n## FROM ## WHERE ##;\n';
+        helper = new CodeEditorSqlHelper({ name: CodeEditorSqlOperations.Delete });
+        result = helper.getInitCode();
+        expect(result).toEqual(correctInitCode);
+      });
+    });
+
+    describe('and operation is CREATE TABLE', () => {
+      it('should return proper init code', () => {
+        const correctInitCode = 'CREATE TABLE\n## VALUES ##;\n';
+        helper = new CodeEditorSqlHelper({ name: CodeEditorSqlOperations.CreateTable });
+        result = helper.getInitCode();
+        expect(result).toEqual(correctInitCode);
+      });
+    });
+
+    describe('and operation is unknown', () => {
+      it('should throw error', () => {
+        helper = new CodeEditorSqlHelper({ name: 'anything' });
+        try {
+          result = helper.getInitCode();
+        } catch (e) {
+          expect(e.message).toEqual('wrong sql operation');
+        }
+      });
+    });
+  });
+
+  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/sql-helper.ts

@@ -0,0 +1,44 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorSqlOperations,
+} from './code-editor-helper.model';
+
+export class CodeEditorSqlHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Sql;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}${this.getOperationCode()}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `${funcName || ''}\n`;
+  }
+
+  private getOperationCode(): string {
+    const { name: funcName } = this.functionOptions;
+
+    switch (funcName) {
+      case CodeEditorSqlOperations.Select:
+        return '## FROM ## WHERE ##;\n';
+      case CodeEditorSqlOperations.Update:
+        return '## SET ## WHERE ##;\n';
+      case CodeEditorSqlOperations.Insert:
+        return 'INTO ## WHERE ##;\n';
+      case CodeEditorSqlOperations.Delete:
+        return '## FROM ## WHERE ##;\n';
+      case CodeEditorSqlOperations.CreateTable:
+        return '## VALUES ##;\n';
+      default:
+        return '';
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorSwiftHelper } from './swift-helper';
+
+describe('CodeEditorSwiftHelper', () => {
+  let helper: CodeEditorSwiftHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    '_ param1: Bool, _ param2: Int, _ param3: Double, _ param4: Float, _ param5: String, _ param6: [Bool], _ param7: [Int], _ param8: [Float]';
+  const correctFuncOpening = `func mockFunction(${paramsList}) -> Bool {\n`;
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorSwiftHelper(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/swift-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 CodeEditorSwiftHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Swift;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Bool',
+    int: 'Int',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: '[Bool]',
+    array_int: '[Int]',
+    array_float: '[Float]',
+    array_double: '[Double]',
+    array_str: '[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 `func ${funcName}(${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;
+  }
+}