MILAB-5933: e2e test-side fixes for Hetzner k3s runner migration

.changeset/new-islands-rhyme.md

@@ -0,0 +1,5 @@
+---
+"@platforma-sdk/workflow-tengo": patch
+---
+
+fix: xsv converter can be launched in k8s installations.

lib/node/pl-client/src/core/client.test.ts

@@ -1,25 +1,25 @@
-import { getTestClient, getTestClientConf } from "../test/test_config";
+import { getTestAdminClient, getTestAdminClientConf } from "../test/test_config";
 import { PlClient } from "./client";
 import { PlDriver, PlDriverDefinition } from "./driver";
 import { Dispatcher, request } from "undici";
 import { GrpcClientProviderFactory } from "./grpc";
 import { test, expect } from "vitest";
 
 test("test client init", async () => {
-  await getTestClient(undefined);
+  await getTestAdminClient(undefined);
 });
 
 test("test client alternative root init", async () => {
   const aRootName = "test_root";
-  const { conf, auth } = await getTestClientConf();
+  const { conf, auth } = await getTestAdminClientConf();
   await PlClient.init({ ...conf, alternativeRoot: aRootName }, auth);
   const clientB = await PlClient.init(conf, auth);
   const result = await clientB.deleteAlternativeRoot(aRootName);
   expect(result).toBe(true);
 });
 
 test("test client init 2", async () => {
-  await getTestClient();
+  await getTestAdminClient();
 });
 
 interface SimpleDriver extends PlDriver {
@@ -46,7 +46,7 @@ const SimpleDriverDefinition: PlDriverDefinition<SimpleDriver> = {
 };
 
 test("test driver", async () => {
-  const client = await getTestClient();
+  const client = await getTestAdminClient();
   const drv = client.getDriver(SimpleDriverDefinition);
   expect(await drv.ping()).toEqual("pong");
 });

lib/node/pl-client/src/core/ll_client.test.ts

@@ -3,6 +3,8 @@ import {
   getTestConfig,
   plAddressToTestConfig,
   getTestLLClient,
+  getTestAdminLLClient,
+  getTestAdminClient,
   getTestClientConf,
 } from "../test/test_config";
 import { TxAPI_Open_Request_WritableTx } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
@@ -144,7 +146,12 @@ test("test https call via proxy", async () => {
 });
 
 test("list user resources returns user root", async () => {
-  const client = await getTestLLClient();
+  // PlClient.init() creates the user root via the legacy path (requires admin role).
+  // After that, listUserResources returns it.
+  const plClient = await getTestAdminClient();
+  await plClient.close();
+
+  const client = await getTestAdminLLClient();
   const responses = await client.listUserResources({ limit: 1 });
 
   // First message is always the user root.

lib/node/pl-client/src/core/ll_client.ts

@@ -474,7 +474,7 @@ export class LLPlClient implements WireClientProviderFactory {
         await cl.getJWTToken(
           {
             expiration: { seconds: ttlSeconds, nanos: 0 },
-            requestedRole: AuthAPI_GetJWTToken_Role.USER,
+            requestedRole: AuthAPI_GetJWTToken_Role.ROLE_UNSPECIFIED,
           },
           { meta },
         ).response
@@ -483,7 +483,7 @@ export class LLPlClient implements WireClientProviderFactory {
       const headers: Record<string, string> = {};
       if (options?.authorization) headers.authorization = options.authorization;
       const resp = cl.POST("/v1/auth/jwt-token", {
-        body: { expiration: `${ttlSeconds}s`, requestedRole: AuthAPI_GetJWTToken_Role.USER },
+        body: { expiration: `${ttlSeconds}s`, requestedRole: AuthAPI_GetJWTToken_Role.ROLE_UNSPECIFIED },
         headers,
       });
       return notEmpty((await resp).data, "REST: empty response for JWT token request").token;

lib/node/pl-client/src/core/ll_transaction.test.ts

@@ -1,4 +1,4 @@
-import { getTestLLClient } from "../test/test_config";
+import { getTestLLClient, getTestAdminLLClient } from "../test/test_config";
 import { TxAPI_Open_Request_WritableTx } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
 import { createLocalResourceId } from "./types";
 import { test, expect } from "vitest";
@@ -79,7 +79,7 @@ test("check timeout error type (passive)", async () => {
 });
 
 test("check timeout error type (active)", async () => {
-  const client = await getTestLLClient();
+  const client = await getTestAdminLLClient();
   const tx = client.createTx(true, { timeout: 500 });
 
   try {
@@ -143,7 +143,7 @@ test("check timeout error type (active)", async () => {
 });
 
 test("check is abort error (active)", async () => {
-  const client = await getTestLLClient();
+  const client = await getTestAdminLLClient();
   const tx = client.createTx(true, { abortSignal: AbortSignal.timeout(100) });
 
   try {

lib/node/pl-client/src/core/transaction.test.ts

@@ -1,4 +1,4 @@
-import { withTempRoot } from "../test/test_config";
+import { withAdminTempRoot } from "../test/test_config";
 import { StructTestResource, ValueTestResource } from "../helpers/pl";
 import { field, toGlobalFieldId, toGlobalResourceId } from "./transaction";
 import { RecoverablePlError } from "./errors";
@@ -7,7 +7,7 @@ import { test, expect } from "vitest";
 import { StatefulPromise } from "./StatefulPromise";
 
 test("get field", async () => {
-  await withTempRoot(async (pl) => {
+  await withAdminTempRoot(async (pl) => {
     const [rr0, theField1] = await pl.withWriteTx("resource1", async (tx) => {
       const r0 = tx.createStruct(StructTestResource);
       const r1 = tx.createStruct(StructTestResource);
@@ -54,7 +54,7 @@ test("get field", async () => {
 });
 
 test("handle absent resource error", async () => {
-  await withTempRoot(async (pl) => {
+  await withAdminTempRoot(async (pl) => {
     const [rr0, ff0] = await pl.withWriteTx("testCreateResource", async (tx) => {
       const r0 = tx.createStruct(StructTestResource);
       const f0 = { resourceId: tx.clientRoot, fieldName: "test0" };
@@ -114,7 +114,7 @@ test("handle absent resource error", async () => {
 });
 
 test("handle KV storage", async () => {
-  await withTempRoot(async (pl) => {
+  await withAdminTempRoot(async (pl) => {
     await pl.withWriteTx("writeKV", async (tx) => {
       tx.setKValue(tx.clientRoot, "a", "a");
       tx.setKValue(tx.clientRoot, "b", "b");
@@ -151,15 +151,15 @@ test("handle KV storage", async () => {
 });
 
 test("handle empty KV storage", async () => {
-  await withTempRoot(async (pl) => {
+  await withAdminTempRoot(async (pl) => {
     await pl.withReadTx("testReadIndividualAndList", async (tx) => {
       expect(await tx.listKeyValuesString(tx.clientRoot)).toEqual([]);
     });
   });
 });
 
 test("handle KV storage 2", async () => {
-  await withTempRoot(async (pl) => {
+  await withAdminTempRoot(async (pl) => {
     const r1 = await pl.withWriteTx("writeKV", async (tx) => {
       const rr1 = tx.createEphemeral(StructTestResource);
       tx.createField(field(rr1, "a"), "Dynamic", rr1);

lib/node/pl-client/src/test/test_config.ts

@@ -19,6 +19,8 @@ export interface TestConfig {
   test_proxy?: string;
   test_user?: string;
   test_password?: string;
+  test_admin_user?: string;
+  test_admin_password?: string;
 }
 
 const CONFIG_FILE = "test_config.json";
@@ -44,6 +46,11 @@ export function getTestConfig(): TestConfig {
 
   if (process.env.PL_TEST_PROXY !== undefined) conf.test_proxy = process.env.PL_TEST_PROXY;
 
+  if (process.env.PL_TEST_ADMIN_USER !== undefined) conf.test_admin_user = process.env.PL_TEST_ADMIN_USER;
+
+  if (process.env.PL_TEST_ADMIN_PASSWORD !== undefined)
+    conf.test_admin_password = process.env.PL_TEST_ADMIN_PASSWORD;
+
   if (conf.address === undefined)
     throw new Error(
       `can't resolve platform address (checked ${CONFIG_FILE} file and PL_ADDRESS environment var)`,
@@ -157,6 +164,70 @@ export async function getTestLLClient(confOverrides: Partial<PlClientConfig> = {
   return await LLPlClient.build({ ...conf, ...confOverrides }, { auth });
 }
 
+export async function getTestAdminClientConf(): Promise<{ conf: PlClientConfig; auth: AuthOps }> {
+  const tConf = getTestConfig();
+
+  if (tConf.test_admin_user === undefined || tConf.test_admin_password === undefined)
+    throw new Error(
+      `No admin auth found in config (${CONFIG_FILE}) or env vars: PL_TEST_ADMIN_USER, PL_TEST_ADMIN_PASSWORD`,
+    );
+
+  const plConf = plAddressToTestConfig(tConf.address);
+  const uClient = await UnauthenticatedPlClient.build(plConf);
+  const authInformation = await uClient.login(tConf.test_admin_user, tConf.test_admin_password);
+
+  return {
+    conf: plConf,
+    auth: {
+      authInformation,
+      onUpdate: () => {},
+      onAuthError: () => {},
+      onUpdateError: () => {},
+    },
+  };
+}
+
+export async function getTestAdminLLClient(confOverrides: Partial<PlClientConfig> = {}) {
+  const { conf, auth } = await getTestAdminClientConf();
+  return await LLPlClient.build({ ...conf, ...confOverrides }, { auth });
+}
+
+export async function getTestAdminClient(
+  alternativeRoot?: string,
+  confOverrides: Partial<PlClientConfig> = {},
+) {
+  const { conf, auth } = await getTestAdminClientConf();
+  if (alternativeRoot !== undefined && conf.alternativeRoot !== undefined)
+    throw new Error("test pl address configured with alternative root");
+  return await PlClient.init({ ...conf, ...confOverrides, alternativeRoot }, auth);
+}
+
+export async function withAdminTempRoot<T>(body: (pl: PlClient) => Promise<T>): Promise<T | void> {
+  const alternativeRoot = `test_${Date.now()}_${randomUUID()}`;
+  let altRootId: OptionalResourceId = NullResourceId;
+  try {
+    const client = await getTestAdminClient(alternativeRoot);
+    altRootId = client.clientRoot;
+    try {
+      const value = await body(client);
+      const rawClient = await getTestAdminClient();
+      try {
+        await rawClient.deleteAlternativeRoot(alternativeRoot);
+      } catch (cleanupErr: any) {
+        console.warn(`Failed to clean up alternative root ${alternativeRoot}:`, cleanupErr.message);
+      } finally {
+        await rawClient.close();
+      }
+      return value;
+    } finally {
+      await client.close();
+    }
+  } catch (err: any) {
+    console.log(`ALTERNATIVE ROOT: ${alternativeRoot} (${resourceIdToString(altRootId)})`);
+    throw err;
+  }
+}
+
 export async function getTestClient(
   alternativeRoot?: string,
   confOverrides: Partial<PlClientConfig> = {},

lib/node/pl-drivers/src/drivers/download_url/driver.test.ts

@@ -1,5 +1,6 @@
 import { TestHelpers } from "@milaboratories/pl-client";
-import { ConsoleLoggerAdapter, HmacSha256Signer } from "@milaboratories/ts-helpers";
+import { HmacSha256Signer } from "@milaboratories/ts-helpers";
+import type { MiLogger } from "@milaboratories/ts-helpers";
 import * as os from "node:os";
 import { text } from "node:stream/consumers";
 import { Readable } from "node:stream";
@@ -10,9 +11,13 @@ import { DownloadUrlDriver } from "./driver";
 import { test, expect } from "vitest";
 import { TestTags } from "@milaboratories/build-configs";
 
+// ponytail: noop logger prevents background TaskProcessor workers from triggering
+// vitest's onUserConsoleLog RPC after test ends, which causes EnvironmentTeardownError
+const noopLogger: MiLogger = { info: () => {}, warn: () => {}, error: () => {} };
+
 test("should download a tar archive and extracts its content and then deleted", async () => {
   await TestHelpers.withTempRoot(async (client) => {
-    const logger = new ConsoleLoggerAdapter();
+    const logger = noopLogger;
     const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "test1-"));
     const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
@@ -41,6 +46,7 @@ test("should download a tar archive and extracts its content and then deleted",
     expect(indexJsCode).toContain("use strict");
 
     c.resetState();
+    await driver.releaseAll();
     await c.awaitChange();
   });
 }, 45000);
@@ -50,7 +56,7 @@ test(
   { tag: [TestTags.Flaky] },
   async () => {
     await TestHelpers.withTempRoot(async (client) => {
-      const logger = new ConsoleLoggerAdapter();
+      const logger = noopLogger;
       const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "test1-"));
       const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
@@ -69,14 +75,15 @@ test(
       expect(url2).not.toBeUndefined();
       expect(url2?.error).not.toBeUndefined();
       expect(url2?.url).toBeUndefined();
+      await driver.releaseAll();
     });
   },
   60000,
 );
 
 test("should abort a downloading process when we reset a state of a computable", async () => {
   await TestHelpers.withTempRoot(async (client) => {
-    const logger = new ConsoleLoggerAdapter();
+    const logger = noopLogger;
     const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "test2-"));
     const driver = new DownloadUrlDriver(logger, client.httpDispatcher, dir, genSigner());
 
@@ -94,6 +101,7 @@ test("should abort a downloading process when we reset a state of a computable",
 
     const url2 = await c.getValue();
     expect(url2).toBeUndefined();
+    await driver.releaseAll();
   });
 });
 

lib/node/pl-drivers/src/drivers/logs.test.ts

@@ -31,7 +31,7 @@ const downloadDriverOps = {
 const useDocker = process.env.PL_TEST_USE_DOCKER === "true";
 
 vi.setConfig({
-  testTimeout: 90000,
+  testTimeout: 180000,
 });
 
 test("should get all logs", async () => {