unit tests

https-sam · https-sam · commit 207ae96d9898 · 2023-03-19T16:18:09.000-06:00
diff --git a/__tests__/code-excution/python.ts b/__tests__/code-excution/python.ts
@@ -0,0 +1,23 @@
+import { CodeContext } from "../../src/types/worker";
+import JobWorker from "../../src/worker";
+import fs from 'fs'
+
+
+describe("Python code excution test", () => {
+  const worker = new JobWorker();
+  
+  it('should calculate a frequency in string', () => {
+    fs.readFile(`${__dirname}/../test-code/python/counter.py`, 'utf8', (_, code) => {
+      const codeContext: CodeContext = {
+        code: code,
+        functionName: "calculate"
+      }
+      worker
+      .startContainer("python3", codeContext)
+      .then((output) => {
+        expect(output).toBe("Counter({'a': 2, 's': 2, 'w': 2, 'e': 2, 'l': 1, 'd': 1, 'k': 1})")
+      })
+      .catch((e) => console.log(e));
+    });
+  })
+})
diff --git a/__tests__/test-code/python/counter.py b/__tests__/test-code/python/counter.py
@@ -1,3 +1,7 @@
 from collections import Counter
-str = "asldkasweew"
-print(Counter(str))
+
+class Execute:
+  def calculate(self):
+    str = "asldkasweew"
+    print(Counter(str))
+
diff --git a/__tests__/worker.ts b/__tests__/worker.ts
@@ -1,6 +1,7 @@
-import { ContainerInitialization } from "../src/types/worker";
+import { mainClassName } from "../src/config";
+import { CodeContext, ContainerInitialization } from "../src/types/worker";
 import JobWorker from "../src/worker";
-import fs from 'fs'
+
 
 describe("Docker initialization test", () => {
 	const worker = new JobWorker();
@@ -27,17 +28,15 @@ describe("Docker initialization test", () => {
 });
 
 
-describe("Python code excution test", () => {
+
+describe("Transform into executable", () => {
   const worker = new JobWorker();
-  
-  it('should calculate a frequency in string', () => {
-      fs.readFile(`${__dirname}/test-code/python/counter.py`, 'utf8', (_, code) => {
-        worker
-      .startContainer("python3", code)
-      .then((output) => {
-        expect(output).toBe("Counter({'a': 2, 's': 2, 'w': 2, 'e': 2, 'l': 1, 'd': 1, 'k': 1})")
-      })
-      .catch((e) => console.log(e));
-    });
-  })
+   it('should instantiate an object and execute the function', () => {
+    const functionName = "solution"
+    const code = worker.transformCodeIntoExecutable("python3", {
+      code: "",
+      functionName: functionName
+    })
+    expect(code).toBe(`\n${mainClassName}().${functionName}()`)
+   })
 })
diff --git a/package.json b/package.json
@@ -2,7 +2,8 @@
 	"scripts": {
 		"start:dev": "npx nodemon",
 		"build": "rimraf ./build && tsc",
-		"test": "jest"
+		"test": "jest",
+    "ct": "rm ./temp/*"
 	},
 	"devDependencies": {
 		"@types/jest": "^29.5.0",
diff --git a/src/config.ts b/src/config.ts
@@ -0,0 +1 @@
+export const mainClassName = "Execute"
diff --git a/src/types/worker.ts b/src/types/worker.ts
@@ -1,6 +1,18 @@
-export type container = "python3" | "javascript";
+export type language = "python3" | "javascript";
 export type fileFormat = "py" | "js";
 
+export interface CodeContext {
+	/**
+	 * raw string code to be excuted
+	 */
+	code: string
+
+	/**
+	 * A method name in class to be executed
+	 */
+	functionName: string
+}
+
 export interface ContainerInitialization {
 	/**
 	 * Indicates whether it successfully created a contaienr
@@ -49,7 +61,7 @@ export interface JobStatus {
 	/**
 	 * the raw data of the target code
 	 */
-	context: string;
+	context: CodeContext;
 
 	/**
 	 * Newly created ontainer ID if exists
diff --git a/src/worker.ts b/src/worker.ts
@@ -3,28 +3,30 @@ import crypto from "crypto";
 import fs from "fs";
 import path from "path";
 import {
+	CodeContext,
 	ContainerInitialization,
 	JobStatus,
 	WriteFileStatus,
-	container,
+	language,
 	fileFormat,
 } from "./types/worker";
+import { mainClassName } from "./config";
 
 class JobWorker {
 	constructor() {}
 
-	private _fileFormats: Record<container, fileFormat> = {
+	private _fileFormats: Record<language, fileFormat> = {
 		python3: "py",
 		javascript: "js",
 	};
 	/**
 	 * Creates an appropriate docker container
 	 * to execute the target code
 	 */
-	createContainer(container: container): Promise<ContainerInitialization> {
+	createContainer(language: language): Promise<ContainerInitialization> {
 		return new Promise((resolve, reject) => {
-			const initCommand = `docker create ${container}`;
-			if (!(container in this._fileFormats)) {
+			const initCommand = `docker create ${language}`;
+			if (!(language in this._fileFormats)) {
 				return reject({
 					error: true,
 					errorMessage: "Invalid container name.",
@@ -53,24 +55,38 @@ class JobWorker {
 	}
 
 	/**
-	 * writes a code into a temp file
+	 * Returns a piece of code that executes a function in a class
+	 * language specific, so defined using switch cases
 	 */
+	transformCodeIntoExecutable(language: language, context: CodeContext) {
+		switch(language) {
+			case "python3": {
+				return `\n${mainClassName}().${context.functionName}()`
+			}
+		}
+	}
 
+	/**
+	 * writes a code into a temp file
+	 */
 	private async writeFile(
-		container: container,
-		context: string
+		language: language,
+		context: CodeContext
 	): Promise<WriteFileStatus> {
 		return new Promise((resolve, reject) => {
 			const fileName = crypto.randomBytes(32).toString("hex");
-			const fileFormat = this._fileFormats[container];
+			const fileFormat = this._fileFormats[language];
 			const filePath = path.join(
 				__dirname,
 				"..",
 				"temp",
 				`${fileName}.${fileFormat}`
 			);
 
-			fs.writeFile(filePath, context, (error) => {
+			// appending a line to execute a specific function
+			context.code += this.transformCodeIntoExecutable(language, context)
+
+			fs.writeFile(filePath, context.code, (error) => {
 				if (error) {
 					reject(error.message);
 				} else {
@@ -104,11 +120,11 @@ class JobWorker {
 	 */
 	copyContext(
 		containerID: string,
-		container: container,
-		context: string
+		language: language,
+		context: CodeContext
 	): Promise<string> {
 		return new Promise(async (resolve, reject) => {
-			this.writeFile(container, context)
+			this.writeFile(language, context)
 				.then(({ filePath, fileFormat }) => {
 					const initCommand = `docker cp ${filePath} ${containerID}:/src/target.${fileFormat}`;
 					child.exec(initCommand, (error, containerID, stderr) => {
@@ -132,12 +148,12 @@ class JobWorker {
 	 *  1] Creates a new container
 	 *  2] Copies the code into the contaienr
 	 */
-	initContainer(container: container, context: string): Promise<JobStatus> {
+	initContainer(language: language, context: CodeContext): Promise<JobStatus> {
 		return new Promise(async (resolve, reject) => {
-			this.createContainer(container)
+			this.createContainer(language)
 				.then(async ({ containerID, error, errorMessage }) => {
 					if (error) return new Error(errorMessage);
-					return this.copyContext(containerID, container, context)
+					return this.copyContext(containerID, language, context)
 						.then(() => {
 							resolve({
 								message: `Job has succedded.`,
@@ -167,9 +183,9 @@ class JobWorker {
 	 * 1] Spin up the container
 	 * 2] Record the output from the container
 	 */
-	startContainer(container: container, context: string): Promise<string> {
+	startContainer(language: language, context: CodeContext): Promise<string> {
 		return new Promise((resolve, reject) => {
-			this.initContainer(container, context)
+			this.initContainer(language, context)
 				.then((jobStatus: JobStatus) => {
 					if (!jobStatus.jobFailed && jobStatus.containerID) {
 						const startContainer = `docker start -a ${jobStatus.containerID}`;
