wip(MetaTest): deploy tg(python, ts) from metatest

Author: destifo

typegate/tests/runtimes/python_wasi/python_wasi_test.ts

@@ -4,14 +4,11 @@
 import { assert, assertEquals } from "std/assert/mod.ts";
 import { gql, Meta } from "../../utils/mod.ts";
 import { PythonVirtualMachine } from "../../../src/runtimes/python_wasi/python_vm.ts";
-// import { QueryEngine } from "../../../src/engine/query_engine.ts";
-import { BasicAuth, tgDeploy, tgRemove } from "@typegraph/sdk/tg_deploy.js";
 import { testDir } from "test-utils/dir.ts";
 import { tg } from "./python_wasi.ts";
 import * as path from "std/path/mod.ts";
 
-const cwdDir = path.join(testDir, "runtimes/python_wasi");
-const auth = new BasicAuth("admin", "password");
+const cwd = path.join(testDir, "runtimes/python_wasi");
 
 Meta.test("Python WASI VM performance", async (t) => {
   const vm = new PythonVirtualMachine();
@@ -63,36 +60,6 @@ Meta.test("Python WASI VM performance", async (t) => {
   await vm.destroy();
 });
 
-const deployTypegraph = async (gate: string) => {
-  const { serialized, typegate: gateResponseAdd } = await tgDeploy(tg, {
-    baseUrl: gate,
-    auth,
-    artifactsConfig: {
-      prismaMigration: {
-        globalAction: {
-          create: true,
-          reset: false,
-        },
-        migrationDir: "prisma-migrations",
-      },
-      dir: cwdDir,
-    },
-    typegraphPath: path.join(cwdDir, "wasmedge.ts"),
-    secrets: {},
-  });
-
-  return { serialized, gateResponseAdd };
-};
-
-const removeTypegraph = async (gate: string) => {
-  const { typegate: gateResponseRem } = await tgRemove(tg, {
-    baseUrl: gate,
-    auth,
-  });
-
-  return gateResponseRem;
-};
-
 // Meta.test("Python WASI runtime", async (t) => {
 //   const e = await t.engine("runtimes/python_wasi/python_wasi.py");
 
@@ -346,14 +313,12 @@ Meta.test({
   port: true,
   systemTypegraphs: true,
 }, async (metaTest) => {
-  const port = metaTest.port;
-  const gate = `http://localhost:${port}`;
-
   await metaTest.should("upload artifacts along with deps", async () => {
-    const { serialized, gateResponseAdd: _gateResponseAdd } =
-      await deployTypegraph(gate);
-
-    const engine = await metaTest.engineFromDeployed(serialized);
+    const engine = await metaTest.engineFromTgDeploy(
+      "runtimes/python_wasi/python_wasi.ts",
+      cwd,
+      tg,
+    );
 
     await gql`
       query {
@@ -373,8 +338,6 @@ Meta.test({
         },
       })
       .on(engine);
-
-    await removeTypegraph(gate);
   });
 });
 

typegate/tests/runtimes/wasmedge/wasmedge.py

@@ -1,3 +1,6 @@
+import os
+import sys
+
 from typegraph.gen.exports.core import (
     ArtifactResolutionConfig,
     MigrationAction,
@@ -27,22 +30,30 @@ def wasmedge(g: Graph):
     )
 
 
-PORT = 7698
+cwd = sys.argv[1]
+PORT = sys.argv[2]
 gate = f"http://localhost:{PORT}"
 auth = BasicAuth("admin", "password")
 
 wasmedge_tg = wasmedge()
-serialized, typegate = tg_deploy(
+deploy_result = tg_deploy(
     wasmedge_tg,
     TypegraphDeployParams(
         base_url=gate,
+        auth=auth,
+        typegraph_path=os.path.join(cwd, "wasmedge.py"),
         artifacts_config=ArtifactResolutionConfig(
+            dir=cwd,
+            prefix=None,
+            disable_artifact_resolution=None,
+            codegen=None,
             prisma_migration=MigrationConfig(
                 migration_dir="prisma-migrations",
                 global_action=MigrationAction(reset=False, create=True),
-            )
+                runtime_actions=None,
+            ),
         ),
     ),
 )
 
-print(serialized)
+print(deploy_result.serialized)

typegate/tests/runtimes/wasmedge/wasmedge_test.ts

@@ -1,64 +1,50 @@
 // Copyright Metatype OÜ, licensed under the Elastic License 2.0.
 // SPDX-License-Identifier: Elastic-2.0
 
-import { BasicAuth, tgDeploy } from "@typegraph/sdk/tg_deploy.js";
 import { gql, Meta } from "test-utils/mod.ts";
 import { testDir } from "test-utils/dir.ts";
 import { tg } from "./wasmedge.ts";
 import * as path from "std/path/mod.ts";
 
-const cwdDir = path.join(testDir, "runtimes/wasmedge");
-const auth = new BasicAuth("admin", "password");
-
-// Meta.test("WasmEdge runtime: Python SDK", async (t) => {
-//   await t.should("works on the Python SDK", async () => {
-//     const serialized = await t.serializeTypegraphFromShell(
-//       "runtimes/wasmedge/wasmedge.py",
-//       SDKLangugage.Python,
-//     );
-
-//     const engine = await t.engineFromDeployed(serialized);
-
-//     await gql`
+const cwd = path.join(testDir, "runtimes/wasmedge");
+
+// Meta.test(
+//   {
+//     name: "WasmEdge runtime: Python SDK",
+//     port: true,
+//     systemTypegraphs: true,
+//   },
+//   async (t) => {
+//     await t.should("works on the Python SDK", async () => {
+//       const engine = await t.engineFromTgDeploy(
+//         "runtimes/wasmedge/wasmedge.py",
+//         cwdDir,
+//       );
+
+//       await gql`
 //       query {
 //         test(a: 1, b: 2)
 //       }
 //     `
-//       .expectData({
-//         test: 3,
-//       })
-//       .on(engine);
-//     await engine.terminate();
-//   });
-// }, { port: port });
+//         .expectData({
+//           test: 3,
+//         })
+//         .on(engine);
+//     });
+//   },
+// );
 
 Meta.test({
   name: "WasmEdge Runtime typescript sdk",
   port: true,
   systemTypegraphs: true,
 }, async (metaTest) => {
-  const port = metaTest.port;
-  const gate = `http://localhost:${port}`;
-
   await metaTest.should("work after deploying artifact", async () => {
-    const { serialized, typegate: _gateResponseAdd } = await tgDeploy(tg, {
-      baseUrl: gate,
-      auth,
-      artifactsConfig: {
-        prismaMigration: {
-          globalAction: {
-            create: true,
-            reset: false,
-          },
-          migrationDir: "prisma-migrations",
-        },
-        dir: cwdDir,
-      },
-      typegraphPath: path.join(cwdDir, "wasmedge.ts"),
-      secrets: {},
-    });
-
-    const engine = await metaTest.engineFromDeployed(serialized);
+    const engine = await metaTest.engineFromTgDeploy(
+      "runtimes/wasmedge/wasmedge.ts",
+      cwd,
+      tg, // tg should be provided for TS SDK typegraph
+    );
 
     await gql`
       query {
@@ -69,6 +55,5 @@ Meta.test({
         test_wasi_ts: 13,
       })
       .on(engine);
-    await engine.terminate();
   });
 });

typegate/tests/utils/test.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Elastic-2.0
 
 import { SystemTypegraph } from "../../src/system_typegraphs.ts";
-import { dirname, join } from "std/path/mod.ts";
+import { basename, dirname, extname, join } from "std/path/mod.ts";
 import { newTempDir, testDir } from "./dir.ts";
 import { shell, ShellOptions } from "./shell.ts";
 import { assertSnapshot } from "std/testing/snapshot.ts";
@@ -12,6 +12,7 @@ import { Typegate } from "../../src/typegate/mod.ts";
 import { createMetaCli } from "./meta.ts";
 import { TypeGraph } from "../../src/typegraph/mod.ts";
 import { SyncConfig } from "../../src/sync/config.ts";
+import { BasicAuth, tgDeploy } from "@typegraph/sdk/tg_deploy.js";
 
 type AssertSnapshotParams = typeof assertSnapshot extends (
   ctx: Deno.TestContext,
@@ -198,12 +199,84 @@ export class MetaTest {
     return engine;
   }
 
-  async serializeTypegraphFromShell(
+  async engineFromTgDeploy(path: string, cwd: string, tg?: any) {
+    const extension = extname(path);
+    let sdkLang: SDKLangugage;
+    switch (extension) {
+      case ".py":
+        sdkLang = SDKLangugage.Python;
+        break;
+      case ".ts":
+        sdkLang = SDKLangugage.TypeScript;
+        break;
+      case ".mjs":
+        sdkLang = SDKLangugage.TypeScript;
+        break;
+      default:
+        throw new Error("Unsupported file type");
+    }
+
+    const serialized = sdkLang === SDKLangugage.Python
+      ? await this.#serializeTypegraphFromShell(path, sdkLang, cwd)
+      : await this.#serializeTypegraphFromTgDeployTs(path, cwd, tg);
+
+    return await this.engineFromDeployed(serialized);
+  }
+
+  async #serializeTypegraphFromTgDeployTs(path: string, cwd: string, tg?: any) {
+    if (!this.port) {
+      throw new Error(
+        "Error: port option in MetaTest config should be set to 'true'",
+      );
+    }
+
+    if (!tg) {
+      throw new Error(
+        "Error: Typegraph ouput needed for serialzing TS SDK typegraph",
+      );
+    }
+
+    const auth = new BasicAuth("admin", "password");
+    const gate = `http://localhost:${this.port}`;
+    const { serialized, typegate: _gateResponseAdd } = await tgDeploy(tg, {
+      baseUrl: gate,
+      auth,
+      artifactsConfig: {
+        prismaMigration: {
+          globalAction: {
+            create: true,
+            reset: false,
+          },
+          migrationDir: "prisma-migrations",
+        },
+        dir: cwd,
+      },
+      typegraphPath: join(cwd, basename(path)),
+      secrets: {},
+    });
+
+    return serialized;
+  }
+
+  async #serializeTypegraphFromShell(
     path: string,
     lang: SDKLangugage,
+    cwd: string,
   ): Promise<string> {
     // run self deployed typegraph
-    const { stderr, stdout } = await this.shell([lang.toString(), path]);
+
+    if (!this.port) {
+      throw new Error(
+        "Error: port option in MetaTest config should be set to 'true'",
+      );
+    }
+
+    const { stderr, stdout } = await this.shell([
+      lang.toString(),
+      path,
+      cwd,
+      this.port.toString(),
+    ]);
 
     if (stderr.length > 0) {
       throw new Error(`${stderr}`);