unit test cases

https-sam · https-sam · commit 39a1c1b145b1 · 2023-03-20T00:14:46.000-06:00
diff --git a/__tests__/code-excution/python.ts b/__tests__/code-excution/python.ts
@@ -13,22 +13,22 @@ describe("Python transform into executable", () => {
 })
 
 
-describe("Python code excution test", () => {
-  
-  it('should calculate a frequency in string', () => {
-    fs.readFile(`${__dirname}/../test-code/python/counter.py`, 'utf8', (_, code) => {
-      const codeContext: CodeContext = {
-        code: code,
-        functionName: "calculate"
-      }
-      const worker = new JobWorker("python3", codeContext);
-      worker
-      .startContainer()
-      .then((response: ExecuteContainer) => {
-        expect(response.codeOutput).toBe("Counter({'a': 2, 's': 2, 'w': 2, 'e': 2, 'l': 1, 'd': 1, 'k': 1})")
-        worker.cleanupJob();
-      })
-      .catch(_ => {});
-    });
-  })
-})
+// TODO needs some work, cannot seem to ready file here, and is being recognized as success
+
+// describe("Python code excution test", () => {
+//   it('should calculate a frequency in string', () => {
+//     expect.assertions(1);
+
+//     fs.readFile(`${__dirname}/../test-code/python/counter.py`, 'utf8', async (error, code) => {
+//       const codeContext: CodeContext = {
+//         code: code,
+//         functionName: "calculate"
+//       }
+//       const worker = new JobWorker("python3", codeContext);
+//       const response = await worker.startContainer()
+//       console.log(response)
+//       expect(response.codeOutput).toBe("Counter({'a': 2, 's': 2, 'w': 2, 'e': 2, 'l': 1, 'd': 1, 'k': 1})")
+//       await worker.cleanupJob();
+//     });
+//   })
+// })
diff --git a/__tests__/worker.ts b/__tests__/worker.ts
@@ -1,60 +1,45 @@
-import { ContainerInitialization } from "../src/types/worker";
 import JobWorker from "../src/worker";
 
 describe("Docker initialization test", () => {
   it("should create a python container", async () => {
     const worker = new JobWorker("python3", { code: "", functionName: "" });
-    worker
-      .createContainer()
-      .then(({ error, containerID }) => {
-        expect(error).toBe(false);
-        expect(containerID).toBeTruthy;
-        worker.removeContainer();
-      })
-      .catch((_) => {});
+    const { error, containerID } = await worker.createContainer()
+    expect(error).toBe(false);
+    expect(containerID).toBeTruthy;
+    await worker.removeContainer();
   });
 
   // TODO write a tast case for writeFile() & copyContext
 
   it("should not create a container", async () => {
-    const worker = new JobWorker("invalidName" as any, {
-      code: "",
-      functionName: "",
-    });
-    worker
-      .createContainer()
-      .catch(
-        ({ error, containerID, errorMessage }: ContainerInitialization) => {
-          expect(error).toBe(true);
-          expect(containerID).toBeFalsy();
-          expect(errorMessage).toBeTruthy();
-        }
-      );
+    const worker = new JobWorker("invalidName" as any, { code: "", functionName: ""});
+    expect.assertions(3);
+    try {
+      await worker.createContainer()
+    } catch ({ error, containerID, errorMessage }: any) {
+      expect(error).toBe(true);
+      expect(containerID).toBeFalsy();
+      expect(errorMessage).toBe("Invalid language name.");
+    }
   });
 
 
   it("should not initialize a container", async () => {
     const worker = new JobWorker("invalidName" as any, { code: "print('Hello World!')", functionName: "" });
-    worker
-      .initContainer()
-      .then(({ error, message }) => {
-        expect(error).toBe(false);
-        expect(message).toBe("Job has succedded.");
-        worker.cleanupJob();
-      })
-      .catch((_) => {});
+    expect.assertions(2);
+    try {
+      await worker.initContainer()
+    } catch ({ error, message }: any) {
+      expect(error).toEqual(true)
+      expect(message).toEqual("Invalid language name.")
+    }
   });
 
   it("should initialize a python container with code in it", async () => {
     const worker = new JobWorker("python3", { code: "print('Hello World!')", functionName: "" });
-    worker
-      .initContainer()
-      .then(({ error, message }) => {
-        expect(error).toBe(false)
-        expect(message).toBeTruthy;
-        expect(message).toBe("Job has succedded.");
-        worker.cleanupJob();
-      })
-      .catch((_) => {});
+    const { error, message } = await worker.initContainer()
+    expect(error).toBe(false)
+    expect(message).toBe("Job has succeeded.");
+    worker.cleanupJob();
   });
 });
diff --git a/src/worker.ts b/src/worker.ts
@@ -38,14 +38,14 @@ class JobWorker {
    */
   createContainer(): Promise<ContainerInitialization> {
     return new Promise((resolve, reject) => {
-      const initCommand = `docker create ${containerMemLimit} ${containerCPULimit} ${this.language}`;
       if (!(this.language in fileFormats)) {
-        return reject({
+        reject({
           error: true,
-          errorMessage: "Invalid container name.",
+          errorMessage: "Invalid language name.",
         });
       }
-
+      
+      const initCommand = `docker create ${containerMemLimit} ${containerCPULimit} ${this.language}`;
       child.exec(initCommand, (error, containerID, stderr) => {
         if (error) {
           reject({
@@ -140,24 +140,27 @@ class JobWorker {
   initContainer(): Promise<JobStatus> {
     return new Promise(async (resolve, reject) => {
       this.createContainer()
-        .then(async ({ error, errorMessage }) => {
-          if (error) return new Error(errorMessage);
-          return this.copyContext()
+      .then(() => {
+          this.copyContext()
             .then(() => {
               resolve({
-                message: `Job has succedded.`,
+                message: `Job has succeeded.`,
                 error: false,
                 retryable: true,
               });
             })
             .catch((e) => {
-              throw new Error(e);
+              reject({
+                message: e,
+                error: true,
+                retryable: true,
+              });
             });
         })
-        .catch((e) => {
+        .catch(({errorMessage}) => {
           reject({
-            message: `Job has failed for the following reason(s): ${e}.`,
-            jobFailed: true,
+            message: errorMessage,
+            error: true,
             retryable: true,
           });
         });
@@ -169,7 +172,7 @@ class JobWorker {
    * 1] Spin up the container
    * 2] Record the output from the container
    */
-  startContainer(): Promise<ExecuteContainer> {
+  async startContainer(): Promise<ExecuteContainer> {
     return new Promise((resolve, reject) => {
       this.initContainer()
         .then((jobStatus: JobStatus) => {
@@ -213,6 +216,7 @@ class JobWorker {
       if (!this.containerID) {
         reject("ContainerID not found.");
       }
+      
       const removeContainer = `docker rm --force ${this.containerID}`;
       child.exec(removeContainer, (error, stdout, stderr) => {
         if (error) {
