From 6be8349f97a2987dbdf1ede4899b61ea876eb6d5 Mon Sep 17 00:00:00 2001
From: Mish <10400064+mishushakov@users.noreply.github.com>
Date: Thu, 15 May 2025 22:10:59 +0200
Subject: [PATCH] added tests for languages other than python

---
 js/tests/envVars.test.ts                  | 115 +++++++++++++++----
 python/tests/async/test_async_env_vars.py | 126 +++++++++++++++------
 python/tests/sync/test_env_vars.py        | 132 ++++++++++++++++------
 3 files changed, 280 insertions(+), 93 deletions(-)

diff --git a/js/tests/envVars.test.ts b/js/tests/envVars.test.ts
index a4d7f3ca..f2e77bce 100644
--- a/js/tests/envVars.test.ts
+++ b/js/tests/envVars.test.ts
@@ -3,8 +3,8 @@ import { expect } from 'vitest'
 import { isDebug, sandboxTest } from './setup'
 import { Sandbox } from '../src'
 
-// Skip this test if we are running in debug mode — the pwd and user in the testing docker container are not the same as in the actual sandbox.
-sandboxTest.skipIf(isDebug)('env vars', async () => {
+// Python tests
+sandboxTest.skipIf(isDebug)('env vars (python)', async () => {
   const sandbox = await Sandbox.create({
     envs: { TEST_ENV_VAR: 'supertest' },
   })
@@ -14,52 +14,121 @@ sandboxTest.skipIf(isDebug)('env vars', async () => {
       `import os; x = os.getenv('TEST_ENV_VAR'); x`
     )
 
-    expect(result.results[0].text.trim()).toEqual('supertest')
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
   } finally {
     await sandbox.kill()
   }
 })
 
-sandboxTest('env vars on sandbox', async ({ sandbox }) => {
+sandboxTest('env vars on sandbox (python)', async ({ sandbox }) => {
   const result = await sandbox.runCode(
     "import os; os.getenv('FOO')",
     { envs: { FOO: 'bar' } }
   )
 
-  expect(result.results[0].text.trim()).toEqual('bar')
+  expect(result.results[0]?.text.trim()).toEqual('bar')
 })
 
-sandboxTest('env vars on sandbox override', async () => {
+// JavaScript tests
+sandboxTest.skipIf(isDebug)('env vars (javascript)', async () => {
   const sandbox = await Sandbox.create({
-    envs: { FOO: 'bar', SBX: 'value' },
+    envs: { TEST_ENV_VAR: 'supertest' },
   })
 
   try {
-    await sandbox.runCode(
-      "import os; os.environ['FOO'] = 'bar'; os.environ['RUNTIME_ENV'] = 'js_runtime'"
+    const result = await sandbox.runCode(
+      `process.env.TEST_ENV_VAR`
     )
+
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars on sandbox (javascript)', async ({ sandbox }) => {
+  const result = await sandbox.runCode(
+    `process.env.FOO`,
+    { envs: { FOO: 'bar' } }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+})
+
+// R tests
+sandboxTest.skipIf(isDebug)('env vars (r)', async () => {
+  const sandbox = await Sandbox.create({
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
     const result = await sandbox.runCode(
-      "import os; os.getenv('FOO')",
-      { envs: { FOO: 'baz' } }
+      `Sys.getenv("TEST_ENV_VAR")`
     )
 
-    expect(result.results[0].text.trim()).toEqual('baz')
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
 
-    const result2 = await sandbox.runCode(
-      "import os; os.getenv('RUNTIME_ENV')"
+sandboxTest('env vars on sandbox (r)', async ({ sandbox }) => {
+  const result = await sandbox.runCode(
+    `Sys.getenv("FOO")`,
+    { envs: { FOO: 'bar' } }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+})
+
+// Java tests
+sandboxTest.skipIf(isDebug)('env vars (java)', async () => {
+  const sandbox = await Sandbox.create({
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `System.getenv("TEST_ENV_VAR")`
     )
-    expect(result2.results[0].text.trim()).toEqual('js_runtime')
 
-    if (!isDebug) {
-      const result3 = await sandbox.runCode(
-        "import os; os.getenv('SBX')"
-      )
-      expect(result3.results[0].text.trim()).toEqual('value')
-    }
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
+  } finally {
+    await sandbox.kill()
+  }
+})
+
+sandboxTest('env vars on sandbox (java)', async ({ sandbox }) => {
+  const result = await sandbox.runCode(
+    `System.getenv("FOO")`,
+    { envs: { FOO: 'bar' } }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+})
 
-    const result4 = await sandbox.runCode("import os; os.getenv('FOO')")
-    expect(result4.results[0].text.trim()).toEqual('bar')
+// Bash tests
+sandboxTest.skipIf(isDebug)('env vars (bash)', async () => {
+  const sandbox = await Sandbox.create({
+    envs: { TEST_ENV_VAR: 'supertest' },
+  })
+
+  try {
+    const result = await sandbox.runCode(
+      `echo $TEST_ENV_VAR`
+    )
+
+    expect(result.results[0]?.text.trim()).toEqual('supertest')
   } finally {
     await sandbox.kill()
   }
 })
+
+sandboxTest('env vars on sandbox (bash)', async ({ sandbox }) => {
+  const result = await sandbox.runCode(
+    `echo $FOO`,
+    { envs: { FOO: 'bar' } }
+  )
+
+  expect(result.results[0]?.text.trim()).toEqual('bar')
+})
diff --git a/python/tests/async/test_async_env_vars.py b/python/tests/async/test_async_env_vars.py
index e9ed59c8..b6d50c60 100644
--- a/python/tests/async/test_async_env_vars.py
+++ b/python/tests/async/test_async_env_vars.py
@@ -3,44 +3,100 @@
 from e2b_code_interpreter.code_interpreter_async import AsyncSandbox
 
 
-# @pytest.mark.skip_debug()
-# async def test_env_vars_sandbox():
-#     sbx = await AsyncSandbox.create(envs={"FOO": "bar"})
-#     try:
-#         result = await sbx.run_code("import os; os.getenv('FOO')")
-#         assert result.text == "bar"
-#     finally:
-#         await sbx.kill()
+@pytest.mark.skip_debug()
+async def test_env_vars_sandbox():
+    sbx = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = await sbx.run_code("import os; os.getenv('TEST_ENV_VAR')")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        await sbx.kill()
 
 
 async def test_env_vars_in_run_code(async_sandbox: AsyncSandbox):
     result = await async_sandbox.run_code(
         "import os; os.getenv('FOO')", envs={"FOO": "bar"}
     )
-    assert result.text == "bar"
-
-
-#
-# async def test_env_vars_override(debug: bool):
-#     sbx = await AsyncSandbox.create(envs={"FOO": "bar", "SBX": "value"})
-#
-#     try:
-#         await sbx.run_code(
-#             "import os; os.environ['FOO'] = 'bar'; os.environ['RUNTIME_ENV'] = 'async_python_runtime'"
-#         )
-#         result = await sbx.run_code("import os; os.getenv('FOO')", envs={"FOO": "baz"})
-#         assert result.text == "baz"
-#
-#         # This can fail if running in debug mode (there's a race condition with the restart kernel test)
-#         result = await sbx.run_code("import os; os.getenv('RUNTIME_ENV')")
-#         assert result.text == "async_python_runtime"
-#
-#         if not debug:
-#             result = await sbx.run_code("import os; os.getenv('SBX')")
-#             assert result.text == "value"
-#
-#         # This can fail if running in debug mode (there's a race condition with the restart kernel test)
-#         result = await sbx.run_code("import os; os.getenv('FOO')")
-#         assert result.text == "bar"
-#     finally:
-#         await sbx.kill()
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# JavaScript tests
+@pytest.mark.skip_debug()
+async def test_env_vars_javascript_sandbox():
+    sbx = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = await sbx.run_code("process.env.TEST_ENV_VAR")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        await sbx.kill()
+
+
+async def test_env_vars_javascript(async_sandbox: AsyncSandbox):
+    result = await async_sandbox.run_code(
+        "process.env.FOO", envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# R tests
+@pytest.mark.skip_debug()
+async def test_env_vars_r_sandbox():
+    sbx = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = await sbx.run_code('Sys.getenv("TEST_ENV_VAR")')
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        await sbx.kill()
+
+
+async def test_env_vars_r(async_sandbox: AsyncSandbox):
+    result = await async_sandbox.run_code(
+        'Sys.getenv("FOO")', envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# Java tests
+@pytest.mark.skip_debug()
+async def test_env_vars_java_sandbox():
+    sbx = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = await sbx.run_code('System.getenv("TEST_ENV_VAR")')
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        await sbx.kill()
+
+
+async def test_env_vars_java(async_sandbox: AsyncSandbox):
+    result = await async_sandbox.run_code(
+        'System.getenv("FOO")', envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# Bash tests
+@pytest.mark.skip_debug()
+async def test_env_vars_bash_sandbox():
+    sbx = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = await sbx.run_code("echo $TEST_ENV_VAR")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        await sbx.kill()
+
+
+async def test_env_vars_bash(async_sandbox: AsyncSandbox):
+    result = await async_sandbox.run_code(
+        "echo $FOO", envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
diff --git a/python/tests/sync/test_env_vars.py b/python/tests/sync/test_env_vars.py
index 13f87a7b..e09f4b38 100644
--- a/python/tests/sync/test_env_vars.py
+++ b/python/tests/sync/test_env_vars.py
@@ -3,38 +3,100 @@
 from e2b_code_interpreter.code_interpreter_sync import Sandbox
 
 
-# @pytest.mark.skip_debug()
-# async def test_env_vars_sandbox():
-#     sbx = Sandbox(envs={"FOO": "bar"})
-#     result = sbx.run_code("import os; os.getenv('FOO')")
-#     assert result.text == "bar"
-#     sbx.kill()
-
-
-async def test_env_vars_in_run_code(sandbox: Sandbox):
-    result = sandbox.run_code("import os; os.getenv('FOO')", envs={"FOO": "bar"})
-    assert result.text == "bar"
-
-
-#
-# async def test_env_vars_override(debug: bool):
-#     sbx = Sandbox(envs={"FOO": "bar", "SBX": "value"})
-#     sbx.run_code(
-#         "import os; os.environ['FOO'] = 'bar'; os.environ['RUNTIME_ENV'] = 'python_runtime'"
-#     )
-#     result = sbx.run_code("import os; os.getenv('FOO')", envs={"FOO": "baz"})
-#     assert result.text == "baz"
-#
-#     # This can fail if running in debug mode (there's a race condition with the restart kernel test)
-#     result = sbx.run_code("import os; os.getenv('RUNTIME_ENV')")
-#     assert result.text == "python_runtime"
-#
-#     if not debug:
-#         result = sbx.run_code("import os; os.getenv('SBX')")
-#         assert result.text == "value"
-#
-#     # This can fail if running in debug mode (there's a race condition with the restart kernel test)
-#     result = sbx.run_code("import os; os.getenv('FOO')")
-#     assert result.text == "bar"
-#
-#     sbx.kill()
+@pytest.mark.skip_debug()
+def test_env_vars_sandbox():
+    sbx = Sandbox(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = sbx.run_code("import os; os.getenv('TEST_ENV_VAR')")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        sbx.kill()
+
+
+def test_env_vars_in_run_code(sandbox: Sandbox):
+    result = sandbox.run_code(
+        "import os; os.getenv('FOO')", envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# JavaScript tests
+@pytest.mark.skip_debug()
+def test_env_vars_javascript_sandbox():
+    sbx = Sandbox(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = sbx.run_code("process.env.TEST_ENV_VAR")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        sbx.kill()
+
+
+def test_env_vars_javascript(sandbox: Sandbox):
+    result = sandbox.run_code(
+        "process.env.FOO", envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# R tests
+@pytest.mark.skip_debug()
+def test_env_vars_r_sandbox():
+    sbx = Sandbox(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = sbx.run_code('Sys.getenv("TEST_ENV_VAR")')
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        sbx.kill()
+
+
+def test_env_vars_r(sandbox: Sandbox):
+    result = sandbox.run_code(
+        'Sys.getenv("FOO")', envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# Java tests
+@pytest.mark.skip_debug()
+def test_env_vars_java_sandbox():
+    sbx = Sandbox(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = sbx.run_code('System.getenv("TEST_ENV_VAR")')
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        sbx.kill()
+
+
+def test_env_vars_java(sandbox: Sandbox):
+    result = sandbox.run_code(
+        'System.getenv("FOO")', envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"
+
+
+# Bash tests
+@pytest.mark.skip_debug()
+def test_env_vars_bash_sandbox():
+    sbx = Sandbox(envs={"TEST_ENV_VAR": "supertest"})
+    try:
+        result = sbx.run_code("echo $TEST_ENV_VAR")
+        assert result.text is not None
+        assert result.text.strip() == "supertest"
+    finally:
+        sbx.kill()
+
+
+def test_env_vars_bash(sandbox: Sandbox):
+    result = sandbox.run_code(
+        "echo $FOO", envs={"FOO": "bar"}
+    )
+    assert result.text is not None
+    assert result.text.strip() == "bar"