Fixes env vars in languages other than Python (#108)

* env var handling in languages other than python

* added bash to env var processing

* reset env variables to global in case of override or delete them after execution

* moved kernel pre-init to lifespan

* removed unused 0001_envs.py

* added tests

* changed logic for setting env vars like setting cwd

* print > logger

* updated JS SDK tests for env vars

* env vars tests for Python

* added env var tests for r

* changed python env var setting using ipython syntax

* fixed setting env vars in java

* fixes r

* updated tests (bash mostly)

* testing resetting to default in case of override

* fix regression in python test

* async http client for requesting env vars

* updated tests - use correct template

* fixes env vars in java

* set global envs on first execution

* removed deno tests due timeout

* fixes async python tests

* fixes sync python tests

* fixes r tests

* small oversight in r async test

---------

Co-authored-by: Jakub Novák <[email protected]>

Author: mishushakov

js/tests/envVars.test.ts

@@ -0,0 +1,69 @@
+import { expect } from 'vitest'
+
+import { isDebug, sandboxTest } from '../setup'
+import { Sandbox } from '../../src'
+
+// Bash Env Vars
+sandboxTest.skipIf(isDebug)('env vars on sandbox (bash)', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `echo $TEST_ENV_VAR`,
+      {
+        language: 'bash',
+      }
+    )
+
+    expect(result.logs.stdout[0]).toEqual('supertest\n')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars per execution (bash)', async ({ sandbox }) => {
+  const result = await sandbox.runCode('echo $FOO', {
+    envs: { FOO: 'bar' },
+    language: 'bash',
+  })
+
+  const result_empty = await sandbox.runCode(
+    'echo ${FOO:-default}',
+    {
+      language: 'bash',
+    }
+  )
+
+  expect(result.logs.stdout[0]).toEqual('bar\n')
+  expect(result_empty.logs.stdout[0]).toEqual('default\n')
+})
+
+sandboxTest.skipIf(isDebug)('env vars overwrite', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `echo $TEST_ENV_VAR`,
+      {
+        language: 'bash',
+        envs: { TEST_ENV_VAR: 'overwrite' },
+      }
+    )
+
+    const result_global_default = await sandbox.runCode(
+      `echo $TEST_ENV_VAR`,
+      {
+        language: 'bash',
+      }
+    )
+
+    expect(result.logs.stdout[0]).toEqual('overwrite\n')
+    expect(result_global_default.logs.stdout[0]).toEqual('supertest\n')
+  } finally {
+    await sandbox.kill()
+  }
+})

js/tests/env_vars/bash.test.ts

@@ -0,0 +1,72 @@
+import { expect } from 'vitest'
+
+import { isDebug, sandboxTest } from '../setup'
+import { Sandbox } from '../../src'
+
+// Java Env Vars
+sandboxTest.skipIf(isDebug)('env vars on sandbox (java)', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `System.getProperty("TEST_ENV_VAR")`,
+      {
+        language: 'java',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars per execution (java)', async ({ sandbox }) => {
+  const result = await sandbox.runCode(
+    `System.getProperty("FOO")`,
+    {
+      envs: { FOO: 'bar' },
+      language: 'java',
+    }
+  )
+
+  const result_empty = await sandbox.runCode(
+    `System.getProperty("FOO", "default")`,
+    {
+      language: 'java',
+    }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+  expect(result_empty.results[0]?.text.trim()).toEqual('default')
+})
+
+sandboxTest.skipIf(isDebug)('env vars overwrite', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `System.getProperty("TEST_ENV_VAR")`,
+      {
+        language: 'java',
+        envs: { TEST_ENV_VAR: 'overwrite' },
+      }
+    )
+
+    const result_global_default = await sandbox.runCode(
+      `System.getProperty("TEST_ENV_VAR")`,
+      {
+        language: 'java',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('overwrite')
+    expect(result_global_default.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})

js/tests/env_vars/java.test.ts

@@ -0,0 +1,69 @@
+import { expect } from 'vitest'
+
+import { isDebug, sandboxTest } from '../setup'
+import { Sandbox } from '../../src'
+
+// JavaScript Env Vars
+sandboxTest.skipIf(isDebug)('env vars on sandbox (javascript)', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `process.env.TEST_ENV_VAR`,
+      {
+        language: 'javascript',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars per execution (javascript)', async ({ sandbox }) => {
+  const result = await sandbox.runCode("process.env.FOO", {
+    envs: { FOO: 'bar' },
+    language: 'javascript',
+  })
+
+  const result_empty = await sandbox.runCode(
+    "process.env.FOO || 'default'",
+    {
+      language: 'javascript',
+    }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+  expect(result_empty.results[0]?.text.trim()).toEqual('default')
+})
+
+sandboxTest.skipIf(isDebug)('env vars overwrite', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `process.env.TEST_ENV_VAR`,
+      {
+        language: 'javascript',
+        envs: { TEST_ENV_VAR: 'overwrite' },
+      }
+    )
+
+    const result_global_default = await sandbox.runCode(
+      `process.env.TEST_ENV_VAR`,
+      {
+        language: 'javascript',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('overwrite')
+    expect(result_global_default.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})

js/tests/env_vars/js.test.ts

@@ -0,0 +1,69 @@
+import { expect } from 'vitest'
+
+import { isDebug, sandboxTest } from '../setup'
+import { Sandbox } from '../../src'
+
+// Python Env Vars
+sandboxTest.skipIf(isDebug)('env vars on sandbox (python)', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `import os; os.getenv('TEST_ENV_VAR')`,
+      {
+        language: 'python',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars per execution (python)', async ({ sandbox }) => {
+  const result = await sandbox.runCode("import os; os.getenv('FOO')", {
+    envs: { FOO: 'bar' },
+    language: 'python',
+  })
+
+  const result_empty = await sandbox.runCode(
+    "import os; os.getenv('FOO', 'default')",
+    {
+      language: 'python',
+    }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+  expect(result_empty.results[0]?.text.trim()).toEqual('default')
+})
+
+sandboxTest.skipIf(isDebug)('env vars overwrite', async ({ template }) => {
+  const sandbox = await Sandbox.create(template, {
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `import os; os.getenv('TEST_ENV_VAR')`,
+      {
+        language: 'python',
+        envs: { TEST_ENV_VAR: 'overwrite' },
+      }
+    )
+
+    const result_global_default = await sandbox.runCode(
+      `import os; os.getenv('TEST_ENV_VAR')`,
+      {
+        language: 'python',
+      }
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('overwrite')
+    expect(result_global_default.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})