From 15cceb901c50d7364ea3b688bba0488ceb41d139 Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Wed, 14 May 2025 21:50:35 +0200 Subject: [PATCH 01/18] env var handling in languages other than python --- template/server/messaging.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/template/server/messaging.py b/template/server/messaging.py index d2894d92..576ebc94 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -183,21 +183,24 @@ async def execute( async with self._lock: if env_vars: vars_to_set = {**global_env_vars, **env_vars} - - # if there is an indent in the code, we need to add the env vars at the beginning of the code - lines = code.split("\n") - indent = 0 - for i, line in enumerate(lines): - if line.strip() != "": - indent = len(line) - len(line.lstrip()) - break + env_vars_snippet = "" if self.language == "python": - code = ( - indent * " " - + f"os.environ.set_envs_for_execution({vars_to_set})\n" - + code - ) + env_vars_snippet = f"os.environ.set_envs_for_execution({vars_to_set})\n" + elif self.language in ["javascript", "typescript"]: + env_vars_snippet = "\n".join([f"process.env['{k}'] = '{v}';" for k, v in vars_to_set.items()]) + elif self.language == "deno": + env_vars_snippet = "\n".join([f"Deno.env.set('{k}', '{v}');" for k, v in vars_to_set.items()]) + elif self.language == "r": + env_vars_snippet = "\n".join([f"Sys.setenv('{k}' = '{v}')" for k, v in vars_to_set.items()]) + elif self.language == "java": + env_vars_snippet = "\n".join([f"System.setProperty('{k}', '{v}');" for k, v in vars_to_set.items()]) + else: + raise Exception(f"Unsupported language: {self.language}") + + print(f"Setting env vars: {env_vars_snippet}") + request = self._get_execute_request(str(uuid.uuid4()), env_vars_snippet, False) + await self._ws.send(request) if self.language == "typescript": logger.info("Compiling TypeScript: %s", code) From 3d9cb5b55725e926021beb3f13dd9ced24c2a38a Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Thu, 15 May 2025 22:13:21 +0200 Subject: [PATCH 02/18] added bash to env var processing --- template/server/messaging.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/template/server/messaging.py b/template/server/messaging.py index 576ebc94..04516453 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -195,6 +195,8 @@ async def execute( env_vars_snippet = "\n".join([f"Sys.setenv('{k}' = '{v}')" for k, v in vars_to_set.items()]) elif self.language == "java": env_vars_snippet = "\n".join([f"System.setProperty('{k}', '{v}');" for k, v in vars_to_set.items()]) + elif self.language == "bash": + env_vars_snippet = "\n".join([f"export {k}='{v}'" for k, v in vars_to_set.items()]) else: raise Exception(f"Unsupported language: {self.language}") From f34cf8f5a413b815f4cbf793e3b9d86f96e84d84 Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Wed, 21 May 2025 16:31:48 +0200 Subject: [PATCH 03/18] reset env variables to global in case of override or delete them after execution --- template/server/contexts.py | 10 ++++ template/server/messaging.py | 92 +++++++++++++++++++++++++++--------- 2 files changed, 79 insertions(+), 23 deletions(-) diff --git a/template/server/contexts.py b/template/server/contexts.py index d078dc6e..82e0c007 100644 --- a/template/server/contexts.py +++ b/template/server/contexts.py @@ -8,6 +8,7 @@ from consts import JUPYTER_BASE_URL from errors import ExecutionError from messaging import ContextWebSocket +from envs import get_envs logger = logging.Logger(__name__) @@ -51,6 +52,7 @@ async def create_context(client, websockets: dict, language: str, cwd: str) -> C session_data = response.json() session_id = session_data["id"] context_id = session_data["kernel"]["id"] + global_env_vars = get_envs() logger.debug(f"Created context {context_id}") @@ -67,4 +69,12 @@ async def create_context(client, websockets: dict, language: str, cwd: str) -> C status_code=500, ) + try: + await ws.set_env_vars(global_env_vars) + except ExecutionError as e: + return PlainTextResponse( + "Failed to set environment variables", + status_code=500, + ) + return Context(language=language, id=context_id, cwd=cwd) diff --git a/template/server/messaging.py b/template/server/messaging.py index 04516453..d7613bf5 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -135,6 +135,69 @@ async def _wait_for_result(self, message_id: str): yield output.model_dump(exclude_none=True) + async def set_env_vars(self, env_vars: Dict[StrictStr, str]): + env_commands = [] + + for k, v in env_vars.items(): + if self.language == "python": + env_commands.append(f"os.environ['{k}'] = '{v}'") + elif self.language in ["javascript", "typescript"]: + env_commands.append(f"process.env['{k}'] = '{v}'") + elif self.language == "deno": + env_commands.append(f"Deno.env.set('{k}', '{v}')") + elif self.language == "r": + env_commands.append(f"Sys.setenv('{k}' = '{v}')") + elif self.language == "java": + env_commands.append(f"System.setProperty('{k}', '{v}')") + elif self.language == "bash": + env_commands.append(f"export {k}='{v}'") + + if env_commands: + env_vars_snippet = "\n".join(env_commands) + print(f"Setting env vars: {env_vars_snippet}") + request = self._get_execute_request(str(uuid.uuid4()), env_vars_snippet, False) + await self._ws.send(request) + + async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): + global_env_vars = get_envs() + + # Create a dict of vars to reset and a list of vars to remove + vars_to_reset = {} + vars_to_remove = [] + + for key in env_vars: + if key in global_env_vars: + vars_to_reset[key] = global_env_vars[key] + else: + vars_to_remove.append(key) + + # Reset vars that exist in global env vars + if vars_to_reset: + await self.set_env_vars(vars_to_reset) + + # Remove vars that don't exist in global env vars + if vars_to_remove: + remove_commands = [] + for key in vars_to_remove: + if self.language == "python": + remove_commands.append(f"del os.environ['{key}']") + elif self.language in ["javascript", "typescript"]: + remove_commands.append(f"delete process.env['{key}']") + elif self.language == "deno": + remove_commands.append(f"Deno.env.delete('{key}')") + elif self.language == "r": + remove_commands.append(f"Sys.unsetenv('{key}')") + elif self.language == "java": + remove_commands.append(f"System.clearProperty('{key}')") + elif self.language == "bash": + remove_commands.append(f"unset {key}") + + if remove_commands: + remove_snippet = "\n".join(remove_commands) + print(f"Removing env vars: {remove_snippet}") + request = self._get_execute_request(str(uuid.uuid4()), remove_snippet, False) + await self._ws.send(request) + async def change_current_directory( self, path: Union[str, StrictStr], language: str ): @@ -178,31 +241,10 @@ async def execute( if self._ws is None: raise Exception("WebSocket not connected") - global_env_vars = get_envs() - env_vars = {**global_env_vars, **env_vars} if env_vars else global_env_vars async with self._lock: + # set env vars (will override global env vars) if env_vars: - vars_to_set = {**global_env_vars, **env_vars} - env_vars_snippet = "" - - if self.language == "python": - env_vars_snippet = f"os.environ.set_envs_for_execution({vars_to_set})\n" - elif self.language in ["javascript", "typescript"]: - env_vars_snippet = "\n".join([f"process.env['{k}'] = '{v}';" for k, v in vars_to_set.items()]) - elif self.language == "deno": - env_vars_snippet = "\n".join([f"Deno.env.set('{k}', '{v}');" for k, v in vars_to_set.items()]) - elif self.language == "r": - env_vars_snippet = "\n".join([f"Sys.setenv('{k}' = '{v}')" for k, v in vars_to_set.items()]) - elif self.language == "java": - env_vars_snippet = "\n".join([f"System.setProperty('{k}', '{v}');" for k, v in vars_to_set.items()]) - elif self.language == "bash": - env_vars_snippet = "\n".join([f"export {k}='{v}'" for k, v in vars_to_set.items()]) - else: - raise Exception(f"Unsupported language: {self.language}") - - print(f"Setting env vars: {env_vars_snippet}") - request = self._get_execute_request(str(uuid.uuid4()), env_vars_snippet, False) - await self._ws.send(request) + await self.set_env_vars(env_vars) if self.language == "typescript": logger.info("Compiling TypeScript: %s", code) @@ -242,6 +284,10 @@ async def execute( del self._executions[message_id] + # reset env vars to their previous values, if they were set globally or remove them + if env_vars: + await self.reset_env_vars(env_vars) + async def _receive_message(self): if not self._ws: logger.error("No WebSocket connection") From bcfba5d8da73fa72ced65c834972b4c558a47d7c Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Tue, 3 Jun 2025 16:26:40 +0200 Subject: [PATCH 04/18] moved kernel pre-init to lifespan --- template/server/main.py | 35 +++++++++++++---------------------- template/server/messaging.py | 4 ++-- template/start-up.sh | 12 ------------ 3 files changed, 15 insertions(+), 36 deletions(-) diff --git a/template/server/main.py b/template/server/main.py index fa7760a9..d28a51fd 100644 --- a/template/server/main.py +++ b/template/server/main.py @@ -34,31 +34,22 @@ async def lifespan(app: FastAPI): global client client = httpx.AsyncClient() - with open("/root/.jupyter/kernel_id") as file: - default_context_id = file.read().strip() - - default_ws = ContextWebSocket( - default_context_id, - str(uuid.uuid4()), - "python", - "/home/user", - ) - default_websockets["python"] = default_context_id - websockets["default"] = default_ws - websockets[default_context_id] = default_ws - - logger.info("Connecting to default runtime") - await default_ws.connect() - - websockets["default"] = default_ws + try: + default_context = await create_context(client, websockets, "python", "/home/user") + default_websockets["python"] = default_context.id + websockets["default"] = websockets[default_context.id] - logger.info("Connected to default runtime") - yield + logger.info("Connected to default runtime") + yield - for ws in websockets.values(): - await ws.close() + # Will cleanup after application shuts down + for ws in websockets.values(): + await ws.close() - await client.aclose() + await client.aclose() + except Exception as e: + logger.error(f"Failed to initialize default context: {e}") + raise app = FastAPI(lifespan=lifespan) diff --git a/template/server/messaging.py b/template/server/messaging.py index 196d20fa..d7a32c02 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -327,7 +327,7 @@ async def _process_message(self, data: dict): elif data["msg_type"] == "stream": if data["content"]["name"] == "stdout": - logger.debug(f"Execution {parent_msg_ig} received stdout") + logger.debug(f"Execution {parent_msg_ig} received stdout: {data['content']['text']}") await queue.put( Stdout( text=data["content"]["text"], timestamp=data["header"]["date"] @@ -335,7 +335,7 @@ async def _process_message(self, data: dict): ) elif data["content"]["name"] == "stderr": - logger.debug(f"Execution {parent_msg_ig} received stderr") + logger.debug(f"Execution {parent_msg_ig} received stderr: {data['content']['text']}") await queue.put( Stderr( text=data["content"]["text"], timestamp=data["header"]["date"] diff --git a/template/start-up.sh b/template/start-up.sh index 735e5811..5d6223ff 100644 --- a/template/start-up.sh +++ b/template/start-up.sh @@ -13,18 +13,6 @@ function start_jupyter_server() { response=$(curl -s -o /dev/null -w "%{http_code}" "http://localhost:8888/api/status") done - response=$(curl -s -X POST "localhost:8888/api/sessions" -H "Content-Type: application/json" -d '{"path": "/home/user", "kernel": {"name": "python3"}, "type": "notebook", "name": "default"}') - status=$(echo "${response}" | jq -r '.kernel.execution_state') - if [[ ${status} != "starting" ]]; then - echo "Error creating kernel: ${response} ${status}" - exit 1 - fi - - sudo mkdir -p /root/.jupyter - kernel_id=$(echo "${response}" | jq -r '.kernel.id') - sudo echo "${kernel_id}" | sudo tee /root/.jupyter/kernel_id >/dev/null - sudo echo "${response}" | sudo tee /root/.jupyter/.session_info >/dev/null - cd /root/.server/ /root/.server/.venv/bin/uvicorn main:app --host 0.0.0.0 --port 49999 --workers 1 --no-access-log --no-use-colors --timeout-keep-alive 640 } From f4a6584fcabb881e1b2c2029f196bb2b47d613ab Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Tue, 3 Jun 2025 16:49:54 +0200 Subject: [PATCH 05/18] removed unused 0001_envs.py --- template/startup_scripts/0001_envs.py | 65 --------------------------- 1 file changed, 65 deletions(-) delete mode 100644 template/startup_scripts/0001_envs.py diff --git a/template/startup_scripts/0001_envs.py b/template/startup_scripts/0001_envs.py deleted file mode 100644 index b58a7bba..00000000 --- a/template/startup_scripts/0001_envs.py +++ /dev/null @@ -1,65 +0,0 @@ -import copy -import os -import IPython - - -class E2BEnviron(os._Environ): - return_values = {} - keys_to_remove = set() - - def __setitem__(self, key, value): - super().__setitem__(key, value) - self.return_values.pop(key, None) - self.keys_to_remove.discard(key) - - def __delitem__(self, key): - super().__delitem__(key) - self.return_values.pop(key, None) - self.keys_to_remove.discard(key) - - def set_envs_for_execution(self, update=None): - update = update or {} - - return_values = { - key: self[key] for key in set(self.keys()).intersection(update.keys()) - } - keys_to_remove = set(update.keys()).difference(self.keys()) - - self.update(update) - - self.return_values = return_values - self.keys_to_remove = keys_to_remove - - def reset_envs_for_execution(self): - keys_to_remove = copy.copy(self.keys_to_remove) - for key in keys_to_remove: - self.pop(key) - - return_values = copy.copy(self.return_values) - self.update(return_values) - - self.keys_to_remove.clear() - self.return_values.clear() - - -e2b_environ = E2BEnviron( - {}, - os.environ.encodekey, - os.environ.decodekey, - os.environ.encodekey, - os.environ.decodekey, -) -e2b_environ.update(os.environ) -os.environ = e2b_environ - - -def reset_envs(*args, **kwargs): - try: - if isinstance(os.environ, E2BEnviron): - os.environ.reset_envs_for_execution() - except Exception as e: - print(f"Failed to reset envs: {e}") - - -ip = IPython.get_ipython() -ip.events.register("post_run_cell", reset_envs) From ab53907f5f1426570f42b98f9b477e7c0352003b Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 14:03:26 +0200 Subject: [PATCH 06/18] added tests --- 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" From 60c1a06ee6b225e7952b2dec42c723d6b0f8381c Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 18:28:00 +0200 Subject: [PATCH 07/18] changed logic for setting env vars like setting cwd --- template/server/messaging.py | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/template/server/messaging.py b/template/server/messaging.py index d7a32c02..a41a2cd5 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -136,11 +136,13 @@ async def _wait_for_result(self, message_id: str): yield output.model_dump(exclude_none=True) async def set_env_vars(self, env_vars: Dict[StrictStr, str]): - env_commands = [] + message_id = str(uuid.uuid4()) + self._executions[message_id] = Execution(in_background=True) + env_commands = [] for k, v in env_vars.items(): if self.language == "python": - env_commands.append(f"os.environ['{k}'] = '{v}'") + env_commands.append(f"import os; os.environ['{k}'] = '{v}'") elif self.language in ["javascript", "typescript"]: env_commands.append(f"process.env['{k}'] = '{v}'") elif self.language == "deno": @@ -151,13 +153,19 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): env_commands.append(f"System.setProperty('{k}', '{v}')") elif self.language == "bash": env_commands.append(f"export {k}='{v}'") + else: + return if env_commands: env_vars_snippet = "\n".join(env_commands) print(f"Setting env vars: {env_vars_snippet}") - request = self._get_execute_request(str(uuid.uuid4()), env_vars_snippet, False) + request = self._get_execute_request(message_id, env_vars_snippet, True) await self._ws.send(request) + async for item in self._wait_for_result(message_id): + if item["type"] == "error": + raise ExecutionError(f"Error during execution: {item}") + async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): global_env_vars = get_envs() @@ -177,10 +185,13 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): # Remove vars that don't exist in global env vars if vars_to_remove: + message_id = str(uuid.uuid4()) + self._executions[message_id] = Execution(in_background=True) + remove_commands = [] for key in vars_to_remove: if self.language == "python": - remove_commands.append(f"del os.environ['{key}']") + remove_commands.append(f"import os; del os.environ['{key}']") elif self.language in ["javascript", "typescript"]: remove_commands.append(f"delete process.env['{key}']") elif self.language == "deno": @@ -191,13 +202,19 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): remove_commands.append(f"System.clearProperty('{key}')") elif self.language == "bash": remove_commands.append(f"unset {key}") + else: + return if remove_commands: remove_snippet = "\n".join(remove_commands) print(f"Removing env vars: {remove_snippet}") - request = self._get_execute_request(str(uuid.uuid4()), remove_snippet, False) + request = self._get_execute_request(message_id, remove_snippet, True) await self._ws.send(request) + async for item in self._wait_for_result(message_id): + if item["type"] == "error": + raise ExecutionError(f"Error during execution: {item}") + async def change_current_directory( self, path: Union[str, StrictStr], language: str ): From b8f0f8e4c16aac84828a9be04252232bc19df319 Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 18:38:09 +0200 Subject: [PATCH 08/18] print > logger --- template/server/messaging.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/template/server/messaging.py b/template/server/messaging.py index a41a2cd5..6f232006 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -158,7 +158,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): if env_commands: env_vars_snippet = "\n".join(env_commands) - print(f"Setting env vars: {env_vars_snippet}") + logger.info(f"Setting env vars: {env_vars_snippet} for {self.language}") request = self._get_execute_request(message_id, env_vars_snippet, True) await self._ws.send(request) @@ -207,7 +207,7 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): if remove_commands: remove_snippet = "\n".join(remove_commands) - print(f"Removing env vars: {remove_snippet}") + logger.info(f"Removing env vars: {remove_snippet} for {self.language}") request = self._get_execute_request(message_id, remove_snippet, True) await self._ws.send(request) From 5370c93615e89ecc23f08c82fa6135e7a7544b0e Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 18:48:43 +0200 Subject: [PATCH 09/18] updated JS SDK tests for env vars --- js/tests/envVars.test.ts | 134 ----------------------------------- js/tests/envs/bash.test.ts | 61 ++++++++++++++++ js/tests/envs/deno.test.ts | 61 ++++++++++++++++ js/tests/envs/java.test.ts | 64 +++++++++++++++++ js/tests/envs/js.test.ts | 61 ++++++++++++++++ js/tests/envs/python.test.ts | 60 ++++++++++++++++ 6 files changed, 307 insertions(+), 134 deletions(-) delete mode 100644 js/tests/envVars.test.ts create mode 100644 js/tests/envs/bash.test.ts create mode 100644 js/tests/envs/deno.test.ts create mode 100644 js/tests/envs/java.test.ts create mode 100644 js/tests/envs/js.test.ts create mode 100644 js/tests/envs/python.test.ts diff --git a/js/tests/envVars.test.ts b/js/tests/envVars.test.ts deleted file mode 100644 index f2e77bce..00000000 --- a/js/tests/envVars.test.ts +++ /dev/null @@ -1,134 +0,0 @@ -import { expect } from 'vitest' - -import { isDebug, sandboxTest } from './setup' -import { Sandbox } from '../src' - -// Python tests -sandboxTest.skipIf(isDebug)('env vars (python)', async () => { - const sandbox = await Sandbox.create({ - envs: { TEST_ENV_VAR: 'supertest' }, - }) - - try { - const result = await sandbox.runCode( - `import os; x = os.getenv('TEST_ENV_VAR'); x` - ) - - expect(result.results[0]?.text.trim()).toEqual('supertest') - } finally { - await sandbox.kill() - } -}) - -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') -}) - -// JavaScript tests -sandboxTest.skipIf(isDebug)('env vars (javascript)', async () => { - const sandbox = await Sandbox.create({ - envs: { TEST_ENV_VAR: 'supertest' }, - }) - - try { - 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( - `Sys.getenv("TEST_ENV_VAR")` - ) - - expect(result.results[0]?.text.trim()).toEqual('supertest') - } finally { - await sandbox.kill() - } -}) - -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(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') -}) - -// 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/js/tests/envs/bash.test.ts b/js/tests/envs/bash.test.ts new file mode 100644 index 00000000..53dc79b9 --- /dev/null +++ b/js/tests/envs/bash.test.ts @@ -0,0 +1,61 @@ +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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `echo $TEST_ENV_VAR`, + { + language: 'bash', + } + ) + + expect(result.results[0]?.text.trim()).toEqual('supertest') + } 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.results[0]?.text.trim()).toEqual('bar') + expect(result_empty.results[0]?.text.trim()).toEqual('default') +}) + +sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `echo $TEST_ENV_VAR`, + { + language: 'bash', + envs: { TEST_ENV_VAR: 'overwrite' }, + } + ) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) diff --git a/js/tests/envs/deno.test.ts b/js/tests/envs/deno.test.ts new file mode 100644 index 00000000..d95be1ec --- /dev/null +++ b/js/tests/envs/deno.test.ts @@ -0,0 +1,61 @@ +import { expect } from 'vitest' + +import { isDebug, sandboxTest } from '../setup' +import { Sandbox } from '../../src' + +// Deno Env Vars +sandboxTest.skipIf(isDebug)('env vars on sandbox (deno)', async () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `Deno.env.get('TEST_ENV_VAR')`, + { + language: 'deno', + } + ) + + expect(result.results[0]?.text.trim()).toEqual('supertest') + } finally { + await sandbox.kill() + } +}) + +sandboxTest('env vars per execution (deno)', async ({ sandbox }) => { + const result = await sandbox.runCode("Deno.env.get('FOO')", { + envs: { FOO: 'bar' }, + language: 'deno', + }) + + const result_empty = await sandbox.runCode( + "Deno.env.get('FOO') ?? 'default'", + { + language: 'deno', + } + ) + + expect(result.results[0]?.text.trim()).toEqual('bar') + expect(result_empty.results[0]?.text.trim()).toEqual('default') +}) + +sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `Deno.env.get('TEST_ENV_VAR')`, + { + language: 'deno', + envs: { TEST_ENV_VAR: 'overwrite' }, + } + ) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) diff --git a/js/tests/envs/java.test.ts b/js/tests/envs/java.test.ts new file mode 100644 index 00000000..34d53978 --- /dev/null +++ b/js/tests/envs/java.test.ts @@ -0,0 +1,64 @@ +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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `System.out.println(System.getenv("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.out.println(System.getenv("FOO"))`, + { + envs: { FOO: 'bar' }, + language: 'java', + } + ) + + const result_empty = await sandbox.runCode( + `System.out.println(System.getenv("FOO") != null ? System.getenv("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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `System.out.println(System.getenv("TEST_ENV_VAR"))`, + { + language: 'java', + envs: { TEST_ENV_VAR: 'overwrite' }, + } + ) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) diff --git a/js/tests/envs/js.test.ts b/js/tests/envs/js.test.ts new file mode 100644 index 00000000..ce24bf0d --- /dev/null +++ b/js/tests/envs/js.test.ts @@ -0,0 +1,61 @@ +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 () => { + const sandbox = await Sandbox.create({ + 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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `process.env.TEST_ENV_VAR`, + { + language: 'javascript', + envs: { TEST_ENV_VAR: 'overwrite' }, + } + ) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) diff --git a/js/tests/envs/python.test.ts b/js/tests/envs/python.test.ts new file mode 100644 index 00000000..82540294 --- /dev/null +++ b/js/tests/envs/python.test.ts @@ -0,0 +1,60 @@ +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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `import os; x = os.getenv('TEST_ENV_VAR'); x`, + { + 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' }, + }) + + 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 () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode( + `import os; x = os.getenv('TEST_ENV_VAR'); x`, + { + language: 'python', + envs: { TEST_ENV_VAR: 'overwrite' }, + } + ) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) From fe6bd96a48f0fad0fda3a5c12655139c20e085dc Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 19:21:15 +0200 Subject: [PATCH 10/18] env vars tests for Python --- js/tests/{envs => env_vars}/bash.test.ts | 0 js/tests/{envs => env_vars}/deno.test.ts | 0 js/tests/{envs => env_vars}/java.test.ts | 0 js/tests/{envs => env_vars}/js.test.ts | 0 js/tests/{envs => env_vars}/python.test.ts | 0 python/tests/async/env_vars/test_bash.py | 50 ++++++++++ python/tests/async/env_vars/test_deno.py | 50 ++++++++++ python/tests/async/env_vars/test_java.py | 50 ++++++++++ python/tests/async/env_vars/test_js.py | 50 ++++++++++ python/tests/async/env_vars/test_python.py | 49 ++++++++++ python/tests/async/test_async_env_vars.py | 102 --------------------- python/tests/sync/env_vars/test_bash.py | 46 ++++++++++ python/tests/sync/env_vars/test_deno.py | 46 ++++++++++ python/tests/sync/env_vars/test_java.py | 46 ++++++++++ python/tests/sync/env_vars/test_js.py | 46 ++++++++++ python/tests/sync/env_vars/test_python.py | 45 +++++++++ python/tests/sync/test_env_vars.py | 102 --------------------- 17 files changed, 478 insertions(+), 204 deletions(-) rename js/tests/{envs => env_vars}/bash.test.ts (100%) rename js/tests/{envs => env_vars}/deno.test.ts (100%) rename js/tests/{envs => env_vars}/java.test.ts (100%) rename js/tests/{envs => env_vars}/js.test.ts (100%) rename js/tests/{envs => env_vars}/python.test.ts (100%) create mode 100644 python/tests/async/env_vars/test_bash.py create mode 100644 python/tests/async/env_vars/test_deno.py create mode 100644 python/tests/async/env_vars/test_java.py create mode 100644 python/tests/async/env_vars/test_js.py create mode 100644 python/tests/async/env_vars/test_python.py delete mode 100644 python/tests/async/test_async_env_vars.py create mode 100644 python/tests/sync/env_vars/test_bash.py create mode 100644 python/tests/sync/env_vars/test_deno.py create mode 100644 python/tests/sync/env_vars/test_java.py create mode 100644 python/tests/sync/env_vars/test_js.py create mode 100644 python/tests/sync/env_vars/test_python.py delete mode 100644 python/tests/sync/test_env_vars.py diff --git a/js/tests/envs/bash.test.ts b/js/tests/env_vars/bash.test.ts similarity index 100% rename from js/tests/envs/bash.test.ts rename to js/tests/env_vars/bash.test.ts diff --git a/js/tests/envs/deno.test.ts b/js/tests/env_vars/deno.test.ts similarity index 100% rename from js/tests/envs/deno.test.ts rename to js/tests/env_vars/deno.test.ts diff --git a/js/tests/envs/java.test.ts b/js/tests/env_vars/java.test.ts similarity index 100% rename from js/tests/envs/java.test.ts rename to js/tests/env_vars/java.test.ts diff --git a/js/tests/envs/js.test.ts b/js/tests/env_vars/js.test.ts similarity index 100% rename from js/tests/envs/js.test.ts rename to js/tests/env_vars/js.test.ts diff --git a/js/tests/envs/python.test.ts b/js/tests/env_vars/python.test.ts similarity index 100% rename from js/tests/envs/python.test.ts rename to js/tests/env_vars/python.test.ts diff --git a/python/tests/async/env_vars/test_bash.py b/python/tests/async/env_vars/test_bash.py new file mode 100644 index 00000000..e8082355 --- /dev/null +++ b/python/tests/async/env_vars/test_bash.py @@ -0,0 +1,50 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "echo $FOO", + envs={"FOO": "bar"}, + language="bash" + ) + + result_empty = await sandbox.run_code( + "echo ${FOO:-default}", + language="bash" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/async/env_vars/test_deno.py b/python/tests/async/env_vars/test_deno.py new file mode 100644 index 00000000..93b96249 --- /dev/null +++ b/python/tests/async/env_vars/test_deno.py @@ -0,0 +1,50 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "Deno.env.get('FOO')", + envs={"FOO": "bar"}, + language="deno" + ) + + result_empty = await sandbox.run_code( + "Deno.env.get('FOO') || 'default'", + language="deno" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/async/env_vars/test_java.py b/python/tests/async/env_vars/test_java.py new file mode 100644 index 00000000..a86ee4a8 --- /dev/null +++ b/python/tests/async/env_vars/test_java.py @@ -0,0 +1,50 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "String x = System.getenv(\"TEST_ENV_VAR\"); x", + language="java" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "System.getenv(\"FOO\")", + envs={"FOO": "bar"}, + language="java" + ) + + result_empty = await sandbox.run_code( + "String value = System.getenv(\"FOO\"); value != null ? value : \"default\"", + language="java" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "String x = System.getenv(\"TEST_ENV_VAR\"); x", + language="java", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/async/env_vars/test_js.py b/python/tests/async/env_vars/test_js.py new file mode 100644 index 00000000..89b6fab0 --- /dev/null +++ b/python/tests/async/env_vars/test_js.py @@ -0,0 +1,50 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "process.env.FOO", + envs={"FOO": "bar"}, + language="javascript" + ) + + result_empty = await sandbox.run_code( + "process.env.FOO || 'default'", + language="javascript" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/async/env_vars/test_python.py b/python/tests/async/env_vars/test_python.py new file mode 100644 index 00000000..9ca19b9b --- /dev/null +++ b/python/tests/async/env_vars/test_python.py @@ -0,0 +1,49 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "import os; x = os.getenv('TEST_ENV_VAR'); x", + language="python" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "import os; os.getenv('FOO')", + envs={"FOO": "bar"} + ) + + result_empty = await sandbox.run_code( + "import os; os.getenv('FOO', 'default')", + language="python" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "import os; x = os.getenv('TEST_ENV_VAR'); x", + language="python", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/async/test_async_env_vars.py b/python/tests/async/test_async_env_vars.py deleted file mode 100644 index b6d50c60..00000000 --- a/python/tests/async/test_async_env_vars.py +++ /dev/null @@ -1,102 +0,0 @@ -import pytest - -from e2b_code_interpreter.code_interpreter_async import AsyncSandbox - - -@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 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/env_vars/test_bash.py b/python/tests/sync/env_vars/test_bash.py new file mode 100644 index 00000000..45411eeb --- /dev/null +++ b/python/tests/sync/env_vars/test_bash.py @@ -0,0 +1,46 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "echo $FOO", + envs={"FOO": "bar"}, + language="bash" + ) + + result_empty = sandbox.run_code( + "echo ${FOO:-default}", + language="bash" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() diff --git a/python/tests/sync/env_vars/test_deno.py b/python/tests/sync/env_vars/test_deno.py new file mode 100644 index 00000000..a7503d51 --- /dev/null +++ b/python/tests/sync/env_vars/test_deno.py @@ -0,0 +1,46 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "Deno.env.get('FOO')", + envs={"FOO": "bar"}, + language="deno" + ) + + result_empty = sandbox.run_code( + "Deno.env.get('FOO') || 'default'", + language="deno" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() diff --git a/python/tests/sync/env_vars/test_java.py b/python/tests/sync/env_vars/test_java.py new file mode 100644 index 00000000..33650126 --- /dev/null +++ b/python/tests/sync/env_vars/test_java.py @@ -0,0 +1,46 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "String x = System.getenv(\"TEST_ENV_VAR\"); x", + language="java" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "System.getenv(\"FOO\")", + envs={"FOO": "bar"}, + language="java" + ) + + result_empty = sandbox.run_code( + "String value = System.getenv(\"FOO\"); value != null ? value : \"default\"", + language="java" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "String x = System.getenv(\"TEST_ENV_VAR\"); x", + language="java", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() diff --git a/python/tests/sync/env_vars/test_js.py b/python/tests/sync/env_vars/test_js.py new file mode 100644 index 00000000..80ed0991 --- /dev/null +++ b/python/tests/sync/env_vars/test_js.py @@ -0,0 +1,46 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "process.env.FOO", + envs={"FOO": "bar"}, + language="javascript" + ) + + result_empty = sandbox.run_code( + "process.env.FOO || 'default'", + language="javascript" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() diff --git a/python/tests/sync/env_vars/test_python.py b/python/tests/sync/env_vars/test_python.py new file mode 100644 index 00000000..4afa7eaf --- /dev/null +++ b/python/tests/sync/env_vars/test_python.py @@ -0,0 +1,45 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "import os; x = os.getenv('TEST_ENV_VAR'); x", + language="python" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "import os; os.getenv('FOO')", + envs={"FOO": "bar"} + ) + + result_empty = sandbox.run_code( + "import os; os.getenv('FOO', 'default')", + language="python" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "import os; x = os.getenv('TEST_ENV_VAR'); x", + language="python", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() diff --git a/python/tests/sync/test_env_vars.py b/python/tests/sync/test_env_vars.py deleted file mode 100644 index e09f4b38..00000000 --- a/python/tests/sync/test_env_vars.py +++ /dev/null @@ -1,102 +0,0 @@ -import pytest - -from e2b_code_interpreter.code_interpreter_sync import Sandbox - - -@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" From 1ba871831afcbf36c98025ff181cbc09158a403f Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 21:13:59 +0200 Subject: [PATCH 11/18] added env var tests for r --- js/tests/env_vars/r.test.ts | 54 +++++++++++++++++++++++++++ python/tests/async/env_vars/test_r.py | 50 +++++++++++++++++++++++++ python/tests/sync/env_vars/test_r.py | 46 +++++++++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 js/tests/env_vars/r.test.ts create mode 100644 python/tests/async/env_vars/test_r.py create mode 100644 python/tests/sync/env_vars/test_r.py diff --git a/js/tests/env_vars/r.test.ts b/js/tests/env_vars/r.test.ts new file mode 100644 index 00000000..a0a0dd2a --- /dev/null +++ b/js/tests/env_vars/r.test.ts @@ -0,0 +1,54 @@ +import { expect } from 'vitest' + +import { isDebug, sandboxTest } from '../setup' +import { Sandbox } from '../../src' + +// R Env Vars +sandboxTest.skipIf(isDebug)('env vars on sandbox (R)', async () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode(`Sys.getenv("TEST_ENV_VAR")`, { + language: 'r', + }) + + expect(result.results[0]?.text.trim()).toEqual('supertest') + } finally { + await sandbox.kill() + } +}) + +sandboxTest('env vars per execution (R)', async ({ sandbox }) => { + const result = await sandbox.runCode('Sys.getenv("FOO")', { + envs: { FOO: 'bar' }, + }) + + const result_empty = await sandbox.runCode( + 'Sys.getenv("FOO", unset = "default")', + { + language: 'r', + } + ) + + expect(result.results[0]?.text.trim()).toEqual('bar') + expect(result_empty.results[0]?.text.trim()).toEqual('default') +}) + +sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { + const sandbox = await Sandbox.create({ + envs: { TEST_ENV_VAR: 'supertest' }, + }) + + try { + const result = await sandbox.runCode(`Sys.getenv("TEST_ENV_VAR")`, { + language: 'r', + envs: { TEST_ENV_VAR: 'overwrite' }, + }) + + expect(result.results[0]?.text.trim()).toEqual('overwrite') + } finally { + await sandbox.kill() + } +}) diff --git a/python/tests/async/env_vars/test_r.py b/python/tests/async/env_vars/test_r.py new file mode 100644 index 00000000..7eecc728 --- /dev/null +++ b/python/tests/async/env_vars/test_r.py @@ -0,0 +1,50 @@ +import pytest +from e2b_code_interpreter.code_interpreter_async import AsyncSandbox + +@pytest.mark.skip_debug() +async def test_env_vars_on_sandbox(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "Sys.getenv('TEST_ENV_VAR')", + language="r" + ) + assert result.text is not None + assert result.text.strip() == "supertest" + finally: + await sandbox.kill() + +async def test_env_vars_per_execution(): + sandbox = await AsyncSandbox.create() + try: + result = await sandbox.run_code( + "Sys.getenv('FOO')", + envs={"FOO": "bar"}, + language="r" + ) + + result_empty = await sandbox.run_code( + "Sys.getenv('FOO', unset = 'default')", + language="r" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" + finally: + await sandbox.kill() + +@pytest.mark.skip_debug() +async def test_env_vars_overwrite(): + sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = await sandbox.run_code( + "Sys.getenv('TEST_ENV_VAR')", + language="r", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.text is not None + assert result.text.strip() == "overwrite" + finally: + await sandbox.kill() diff --git a/python/tests/sync/env_vars/test_r.py b/python/tests/sync/env_vars/test_r.py new file mode 100644 index 00000000..50535910 --- /dev/null +++ b/python/tests/sync/env_vars/test_r.py @@ -0,0 +1,46 @@ +import pytest +from e2b_code_interpreter import Sandbox + +@pytest.mark.skip_debug() +def test_env_vars_on_sandbox(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "Sys.getenv('TEST_ENV_VAR')", + language="r" + ) + assert result.results[0].text.strip() == "supertest" + finally: + sandbox.kill() + +def test_env_vars_per_execution(): + sandbox = Sandbox() + try: + result = sandbox.run_code( + "Sys.getenv('FOO')", + envs={"FOO": "bar"}, + language="r" + ) + + result_empty = sandbox.run_code( + "Sys.getenv('FOO', unset = 'default')", + language="r" + ) + + assert result.results[0].text.strip() == "bar" + assert result_empty.results[0].text.strip() == "default" + finally: + sandbox.kill() + +@pytest.mark.skip_debug() +def test_env_vars_overwrite(): + sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) + try: + result = sandbox.run_code( + "Sys.getenv('TEST_ENV_VAR')", + language="r", + envs={"TEST_ENV_VAR": "overwrite"} + ) + assert result.results[0].text.strip() == "overwrite" + finally: + sandbox.kill() From ad926185a239e91a2897300f14b793bcee5fa97a Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 21:28:28 +0200 Subject: [PATCH 12/18] changed python env var setting using ipython syntax --- template/server/messaging.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/template/server/messaging.py b/template/server/messaging.py index 6f232006..f25a86d6 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -142,7 +142,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): env_commands = [] for k, v in env_vars.items(): if self.language == "python": - env_commands.append(f"import os; os.environ['{k}'] = '{v}'") + env_commands.append(f"%env {k}={v}") elif self.language in ["javascript", "typescript"]: env_commands.append(f"process.env['{k}'] = '{v}'") elif self.language == "deno": @@ -191,7 +191,7 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): remove_commands = [] for key in vars_to_remove: if self.language == "python": - remove_commands.append(f"import os; del os.environ['{key}']") + remove_commands.append(f"%env -u {key}") elif self.language in ["javascript", "typescript"]: remove_commands.append(f"delete process.env['{key}']") elif self.language == "deno": From de3bb5d0805d19f7e20bdde1aec7e9895867404b Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 21:39:26 +0200 Subject: [PATCH 13/18] fixed setting env vars in java --- js/tests/env_vars/java.test.ts | 8 ++++---- js/tests/env_vars/python.test.ts | 5 +++-- python/tests/async/env_vars/test_java.py | 8 ++++---- python/tests/async/env_vars/test_python.py | 7 ++++--- python/tests/sync/env_vars/test_java.py | 8 ++++---- python/tests/sync/env_vars/test_python.py | 7 ++++--- template/server/messaging.py | 4 ++-- 7 files changed, 25 insertions(+), 22 deletions(-) diff --git a/js/tests/env_vars/java.test.ts b/js/tests/env_vars/java.test.ts index 34d53978..fad4ff68 100644 --- a/js/tests/env_vars/java.test.ts +++ b/js/tests/env_vars/java.test.ts @@ -11,7 +11,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (java)', async () => { try { const result = await sandbox.runCode( - `System.out.println(System.getenv("TEST_ENV_VAR"))`, + `System.getProperty("TEST_ENV_VAR")`, { language: 'java', } @@ -25,7 +25,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (java)', async () => { sandboxTest('env vars per execution (java)', async ({ sandbox }) => { const result = await sandbox.runCode( - `System.out.println(System.getenv("FOO"))`, + `System.getProperty("FOO")`, { envs: { FOO: 'bar' }, language: 'java', @@ -33,7 +33,7 @@ sandboxTest('env vars per execution (java)', async ({ sandbox }) => { ) const result_empty = await sandbox.runCode( - `System.out.println(System.getenv("FOO") != null ? System.getenv("FOO") : "default")`, + `System.getProperty("FOO", "default")`, { language: 'java', } @@ -50,7 +50,7 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { try { const result = await sandbox.runCode( - `System.out.println(System.getenv("TEST_ENV_VAR"))`, + `System.getProperty("TEST_ENV_VAR")`, { language: 'java', envs: { TEST_ENV_VAR: 'overwrite' }, diff --git a/js/tests/env_vars/python.test.ts b/js/tests/env_vars/python.test.ts index 82540294..912f9d60 100644 --- a/js/tests/env_vars/python.test.ts +++ b/js/tests/env_vars/python.test.ts @@ -11,7 +11,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (python)', async () => { try { const result = await sandbox.runCode( - `import os; x = os.getenv('TEST_ENV_VAR'); x`, + `import os; os.getenv('TEST_ENV_VAR')`, { language: 'python', } @@ -26,6 +26,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (python)', async () => { 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( @@ -46,7 +47,7 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { try { const result = await sandbox.runCode( - `import os; x = os.getenv('TEST_ENV_VAR'); x`, + `import os; os.getenv('TEST_ENV_VAR')`, { language: 'python', envs: { TEST_ENV_VAR: 'overwrite' }, diff --git a/python/tests/async/env_vars/test_java.py b/python/tests/async/env_vars/test_java.py index a86ee4a8..9683e5b7 100644 --- a/python/tests/async/env_vars/test_java.py +++ b/python/tests/async/env_vars/test_java.py @@ -6,7 +6,7 @@ async def test_env_vars_on_sandbox(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "String x = System.getenv(\"TEST_ENV_VAR\"); x", + 'System.getProperty("TEST_ENV_VAR")', language="java" ) assert result.text is not None @@ -18,13 +18,13 @@ async def test_env_vars_per_execution(): sandbox = await AsyncSandbox.create() try: result = await sandbox.run_code( - "System.getenv(\"FOO\")", + 'System.getProperty("FOO")', envs={"FOO": "bar"}, language="java" ) result_empty = await sandbox.run_code( - "String value = System.getenv(\"FOO\"); value != null ? value : \"default\"", + 'System.getProperty("FOO", "default")', language="java" ) @@ -40,7 +40,7 @@ async def test_env_vars_overwrite(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "String x = System.getenv(\"TEST_ENV_VAR\"); x", + 'System.getProperty("TEST_ENV_VAR")', language="java", envs={"TEST_ENV_VAR": "overwrite"} ) diff --git a/python/tests/async/env_vars/test_python.py b/python/tests/async/env_vars/test_python.py index 9ca19b9b..8ca93d6f 100644 --- a/python/tests/async/env_vars/test_python.py +++ b/python/tests/async/env_vars/test_python.py @@ -6,7 +6,7 @@ async def test_env_vars_on_sandbox(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "import os; x = os.getenv('TEST_ENV_VAR'); x", + "import os; os.getenv('TEST_ENV_VAR')", language="python" ) assert result.text is not None @@ -19,7 +19,8 @@ async def test_env_vars_per_execution(): try: result = await sandbox.run_code( "import os; os.getenv('FOO')", - envs={"FOO": "bar"} + envs={"FOO": "bar"}, + language="python" ) result_empty = await sandbox.run_code( @@ -39,7 +40,7 @@ async def test_env_vars_overwrite(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "import os; x = os.getenv('TEST_ENV_VAR'); x", + "import os; os.getenv('TEST_ENV_VAR')", language="python", envs={"TEST_ENV_VAR": "overwrite"} ) diff --git a/python/tests/sync/env_vars/test_java.py b/python/tests/sync/env_vars/test_java.py index 33650126..9e3bc168 100644 --- a/python/tests/sync/env_vars/test_java.py +++ b/python/tests/sync/env_vars/test_java.py @@ -6,7 +6,7 @@ def test_env_vars_on_sandbox(): sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) try: result = sandbox.run_code( - "String x = System.getenv(\"TEST_ENV_VAR\"); x", + 'System.getProperty("TEST_ENV_VAR")', language="java" ) assert result.results[0].text.strip() == "supertest" @@ -17,13 +17,13 @@ def test_env_vars_per_execution(): sandbox = Sandbox() try: result = sandbox.run_code( - "System.getenv(\"FOO\")", + 'System.getProperty("FOO")', envs={"FOO": "bar"}, language="java" ) result_empty = sandbox.run_code( - "String value = System.getenv(\"FOO\"); value != null ? value : \"default\"", + 'System.getProperty("FOO", "default")', language="java" ) @@ -37,7 +37,7 @@ def test_env_vars_overwrite(): sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) try: result = sandbox.run_code( - "String x = System.getenv(\"TEST_ENV_VAR\"); x", + 'System.getProperty("TEST_ENV_VAR")', language="java", envs={"TEST_ENV_VAR": "overwrite"} ) diff --git a/python/tests/sync/env_vars/test_python.py b/python/tests/sync/env_vars/test_python.py index 4afa7eaf..4c46f482 100644 --- a/python/tests/sync/env_vars/test_python.py +++ b/python/tests/sync/env_vars/test_python.py @@ -6,7 +6,7 @@ def test_env_vars_on_sandbox(): sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) try: result = sandbox.run_code( - "import os; x = os.getenv('TEST_ENV_VAR'); x", + "import os; os.getenv('TEST_ENV_VAR')", language="python" ) assert result.results[0].text.strip() == "supertest" @@ -18,7 +18,8 @@ def test_env_vars_per_execution(): try: result = sandbox.run_code( "import os; os.getenv('FOO')", - envs={"FOO": "bar"} + envs={"FOO": "bar"}, + language="python" ) result_empty = sandbox.run_code( @@ -36,7 +37,7 @@ def test_env_vars_overwrite(): sandbox = Sandbox(envs={"TEST_ENV_VAR": "supertest"}) try: result = sandbox.run_code( - "import os; x = os.getenv('TEST_ENV_VAR'); x", + "import os; os.getenv('TEST_ENV_VAR')", language="python", envs={"TEST_ENV_VAR": "overwrite"} ) diff --git a/template/server/messaging.py b/template/server/messaging.py index f25a86d6..ec7f647d 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -150,7 +150,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): elif self.language == "r": env_commands.append(f"Sys.setenv('{k}' = '{v}')") elif self.language == "java": - env_commands.append(f"System.setProperty('{k}', '{v}')") + env_commands.append(f'System.setProperty("{k}", "{v}")') elif self.language == "bash": env_commands.append(f"export {k}='{v}'") else: @@ -199,7 +199,7 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): elif self.language == "r": remove_commands.append(f"Sys.unsetenv('{key}')") elif self.language == "java": - remove_commands.append(f"System.clearProperty('{key}')") + remove_commands.append(f'System.clearProperty("{key}")') elif self.language == "bash": remove_commands.append(f"unset {key}") else: From 1845152a9534cbfef3f72970487d63d8607d524f Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 21:57:12 +0200 Subject: [PATCH 14/18] fixes r --- js/tests/env_vars/r.test.ts | 9 +++++---- python/tests/async/env_vars/test_r.py | 16 ++++++++-------- python/tests/sync/env_vars/test_r.py | 8 ++++---- template/server/messaging.py | 2 +- 4 files changed, 18 insertions(+), 17 deletions(-) diff --git a/js/tests/env_vars/r.test.ts b/js/tests/env_vars/r.test.ts index a0a0dd2a..381acf18 100644 --- a/js/tests/env_vars/r.test.ts +++ b/js/tests/env_vars/r.test.ts @@ -14,7 +14,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (R)', async () => { language: 'r', }) - expect(result.results[0]?.text.trim()).toEqual('supertest') + expect(result.results[0]?.text.trim()).toEqual(`[1] "supertest"`) } finally { await sandbox.kill() } @@ -23,6 +23,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (R)', async () => { sandboxTest('env vars per execution (R)', async ({ sandbox }) => { const result = await sandbox.runCode('Sys.getenv("FOO")', { envs: { FOO: 'bar' }, + language: 'r', }) const result_empty = await sandbox.runCode( @@ -32,8 +33,8 @@ sandboxTest('env vars per execution (R)', async ({ sandbox }) => { } ) - expect(result.results[0]?.text.trim()).toEqual('bar') - expect(result_empty.results[0]?.text.trim()).toEqual('default') + expect(result.results[0]?.text.trim()).toEqual(`[1] "bar"`) + expect(result_empty.results[0]?.text.trim()).toEqual(`[1] "default"`) }) sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { @@ -47,7 +48,7 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { envs: { TEST_ENV_VAR: 'overwrite' }, }) - expect(result.results[0]?.text.trim()).toEqual('overwrite') + expect(result.results[0]?.text.trim()).toEqual(`[1] "overwrite"`) } finally { await sandbox.kill() } diff --git a/python/tests/async/env_vars/test_r.py b/python/tests/async/env_vars/test_r.py index 7eecc728..8864899b 100644 --- a/python/tests/async/env_vars/test_r.py +++ b/python/tests/async/env_vars/test_r.py @@ -6,11 +6,11 @@ async def test_env_vars_on_sandbox(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "Sys.getenv('TEST_ENV_VAR')", + 'Sys.getenv("TEST_ENV_VAR")', language="r" ) assert result.text is not None - assert result.text.strip() == "supertest" + assert result.text.strip() == '[1] "supertest"' finally: await sandbox.kill() @@ -18,20 +18,20 @@ async def test_env_vars_per_execution(): sandbox = await AsyncSandbox.create() try: result = await sandbox.run_code( - "Sys.getenv('FOO')", + 'Sys.getenv("FOO")', envs={"FOO": "bar"}, language="r" ) result_empty = await sandbox.run_code( - "Sys.getenv('FOO', unset = 'default')", + 'Sys.getenv("FOO", unset = "default")', language="r" ) assert result.text is not None - assert result.text.strip() == "bar" + assert result.text.strip() == '[1] "bar"' assert result_empty.text is not None - assert result_empty.text.strip() == "default" + assert result_empty.text.strip() == '[1] "default"' finally: await sandbox.kill() @@ -40,11 +40,11 @@ async def test_env_vars_overwrite(): sandbox = await AsyncSandbox.create(envs={"TEST_ENV_VAR": "supertest"}) try: result = await sandbox.run_code( - "Sys.getenv('TEST_ENV_VAR')", + 'Sys.getenv("TEST_ENV_VAR")', language="r", envs={"TEST_ENV_VAR": "overwrite"} ) assert result.text is not None - assert result.text.strip() == "overwrite" + assert result.text.strip() == '[1] "overwrite"' finally: await sandbox.kill() diff --git a/python/tests/sync/env_vars/test_r.py b/python/tests/sync/env_vars/test_r.py index 50535910..76136e78 100644 --- a/python/tests/sync/env_vars/test_r.py +++ b/python/tests/sync/env_vars/test_r.py @@ -9,7 +9,7 @@ def test_env_vars_on_sandbox(): "Sys.getenv('TEST_ENV_VAR')", language="r" ) - assert result.results[0].text.strip() == "supertest" + assert result.results[0].text.strip() == '[1] "supertest"' finally: sandbox.kill() @@ -27,8 +27,8 @@ def test_env_vars_per_execution(): language="r" ) - assert result.results[0].text.strip() == "bar" - assert result_empty.results[0].text.strip() == "default" + assert result.results[0].text.strip() == '[1] "bar"' + assert result_empty.results[0].text.strip() == '[1] "default"' finally: sandbox.kill() @@ -41,6 +41,6 @@ def test_env_vars_overwrite(): language="r", envs={"TEST_ENV_VAR": "overwrite"} ) - assert result.results[0].text.strip() == "overwrite" + assert result.results[0].text.strip() == '[1] "overwrite"' finally: sandbox.kill() diff --git a/template/server/messaging.py b/template/server/messaging.py index ec7f647d..5ce88db5 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -148,7 +148,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): elif self.language == "deno": env_commands.append(f"Deno.env.set('{k}', '{v}')") elif self.language == "r": - env_commands.append(f"Sys.setenv('{k}' = '{v}')") + env_commands.append(f'Sys.setenv({k} = "{v}")') elif self.language == "java": env_commands.append(f'System.setProperty("{k}", "{v}")') elif self.language == "bash": From 45a18e08776635919dcdd7c4a779742d88cb2d22 Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 22:05:24 +0200 Subject: [PATCH 15/18] updated tests (bash mostly) --- js/tests/env_vars/bash.test.ts | 8 ++--- python/tests/async/env_vars/test_bash.py | 41 +++++++++------------- python/tests/async/env_vars/test_deno.py | 36 +++++++++---------- python/tests/async/env_vars/test_java.py | 36 +++++++++---------- python/tests/async/env_vars/test_js.py | 36 +++++++++---------- python/tests/async/env_vars/test_python.py | 34 ++++++++---------- python/tests/async/env_vars/test_r.py | 36 +++++++++---------- python/tests/sync/env_vars/test_bash.py | 36 +++++++++---------- 8 files changed, 116 insertions(+), 147 deletions(-) diff --git a/js/tests/env_vars/bash.test.ts b/js/tests/env_vars/bash.test.ts index 53dc79b9..7ff8ea84 100644 --- a/js/tests/env_vars/bash.test.ts +++ b/js/tests/env_vars/bash.test.ts @@ -17,7 +17,7 @@ sandboxTest.skipIf(isDebug)('env vars on sandbox (bash)', async () => { } ) - expect(result.results[0]?.text.trim()).toEqual('supertest') + expect(result.logs.stdout[0]).toEqual('supertest\n') } finally { await sandbox.kill() } @@ -36,8 +36,8 @@ sandboxTest('env vars per execution (bash)', async ({ sandbox }) => { } ) - expect(result.results[0]?.text.trim()).toEqual('bar') - expect(result_empty.results[0]?.text.trim()).toEqual('default') + expect(result.logs.stdout[0]).toEqual('bar\n') + expect(result_empty.logs.stdout[0]).toEqual('default\n') }) sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { @@ -54,7 +54,7 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) - expect(result.results[0]?.text.trim()).toEqual('overwrite') + expect(result.logs.stdout[0]).toEqual('overwrite\n') } finally { await sandbox.kill() } diff --git a/python/tests/async/env_vars/test_bash.py b/python/tests/async/env_vars/test_bash.py index e8082355..4674346f 100644 --- a/python/tests/async/env_vars/test_bash.py +++ b/python/tests/async/env_vars/test_bash.py @@ -1,5 +1,6 @@ import pytest from e2b_code_interpreter.code_interpreter_async import AsyncSandbox +from typing import AsyncGenerator @pytest.mark.skip_debug() async def test_env_vars_on_sandbox(): @@ -9,31 +10,24 @@ async def test_env_vars_on_sandbox(): "echo $TEST_ENV_VAR", language="bash" ) - assert result.text is not None - assert result.text.strip() == "supertest" + assert result.logs.stdout[0] == "supertest\n" finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - "echo $FOO", - envs={"FOO": "bar"}, - language="bash" - ) - - result_empty = await sandbox.run_code( - "echo ${FOO:-default}", - language="bash" - ) - - assert result.text is not None - assert result.text.strip() == "bar" - assert result_empty.text is not None - assert result_empty.text.strip() == "default" - finally: - await sandbox.kill() +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + "echo $FOO", + envs={"FOO": "bar"}, + language="bash" + ) + + result_empty = await sandbox.run_code( + "echo ${FOO:-default}", + language="bash" + ) + + assert result.logs.stdout[0] == "bar\n" + assert result_empty.logs.stdout[0] == "default\n" @pytest.mark.skip_debug() async def test_env_vars_overwrite(): @@ -44,7 +38,6 @@ async def test_env_vars_overwrite(): language="bash", envs={"TEST_ENV_VAR": "overwrite"} ) - assert result.text is not None - assert result.text.strip() == "overwrite" + assert result.logs.stdout[0] == "overwrite\n" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_deno.py b/python/tests/async/env_vars/test_deno.py index 93b96249..ce20f369 100644 --- a/python/tests/async/env_vars/test_deno.py +++ b/python/tests/async/env_vars/test_deno.py @@ -14,26 +14,22 @@ async def test_env_vars_on_sandbox(): finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - "Deno.env.get('FOO')", - envs={"FOO": "bar"}, - language="deno" - ) - - result_empty = await sandbox.run_code( - "Deno.env.get('FOO') || 'default'", - language="deno" - ) - - assert result.text is not None - assert result.text.strip() == "bar" - assert result_empty.text is not None - assert result_empty.text.strip() == "default" - finally: - await sandbox.kill() +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + "Deno.env.get('FOO')", + envs={"FOO": "bar"}, + language="deno" + ) + + result_empty = await sandbox.run_code( + "Deno.env.get('FOO') || 'default'", + language="deno" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" @pytest.mark.skip_debug() async def test_env_vars_overwrite(): diff --git a/python/tests/async/env_vars/test_java.py b/python/tests/async/env_vars/test_java.py index 9683e5b7..7475637a 100644 --- a/python/tests/async/env_vars/test_java.py +++ b/python/tests/async/env_vars/test_java.py @@ -14,26 +14,22 @@ async def test_env_vars_on_sandbox(): finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - 'System.getProperty("FOO")', - envs={"FOO": "bar"}, - language="java" - ) - - result_empty = await sandbox.run_code( - 'System.getProperty("FOO", "default")', - language="java" - ) - - assert result.text is not None - assert result.text.strip() == "bar" - assert result_empty.text is not None - assert result_empty.text.strip() == "default" - finally: - await sandbox.kill() +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + 'System.getProperty("FOO")', + envs={"FOO": "bar"}, + language="java" + ) + + result_empty = await sandbox.run_code( + 'System.getProperty("FOO", "default")', + language="java" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" @pytest.mark.skip_debug() async def test_env_vars_overwrite(): diff --git a/python/tests/async/env_vars/test_js.py b/python/tests/async/env_vars/test_js.py index 89b6fab0..6c8f6e06 100644 --- a/python/tests/async/env_vars/test_js.py +++ b/python/tests/async/env_vars/test_js.py @@ -14,26 +14,22 @@ async def test_env_vars_on_sandbox(): finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - "process.env.FOO", - envs={"FOO": "bar"}, - language="javascript" - ) - - result_empty = await sandbox.run_code( - "process.env.FOO || 'default'", - language="javascript" - ) - - assert result.text is not None - assert result.text.strip() == "bar" - assert result_empty.text is not None - assert result_empty.text.strip() == "default" - finally: - await sandbox.kill() +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + "process.env.FOO", + envs={"FOO": "bar"}, + language="javascript" + ) + + result_empty = await sandbox.run_code( + "process.env.FOO || 'default'", + language="javascript" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" @pytest.mark.skip_debug() async def test_env_vars_overwrite(): diff --git a/python/tests/async/env_vars/test_python.py b/python/tests/async/env_vars/test_python.py index 8ca93d6f..b8c0e8d7 100644 --- a/python/tests/async/env_vars/test_python.py +++ b/python/tests/async/env_vars/test_python.py @@ -14,26 +14,22 @@ async def test_env_vars_on_sandbox(): finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - "import os; os.getenv('FOO')", - envs={"FOO": "bar"}, - language="python" - ) - - result_empty = await sandbox.run_code( - "import os; os.getenv('FOO', 'default')", - language="python" +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + "import os; os.getenv('FOO')", + envs={"FOO": "bar"}, + language="python" ) - - assert result.text is not None - assert result.text.strip() == "bar" - assert result_empty.text is not None - assert result_empty.text.strip() == "default" - finally: - await sandbox.kill() + + result_empty = await sandbox.run_code( + "import os; os.getenv('FOO', 'default')", + language="python" + ) + + assert result.text is not None + assert result.text.strip() == "bar" + assert result_empty.text is not None + assert result_empty.text.strip() == "default" @pytest.mark.skip_debug() async def test_env_vars_overwrite(): diff --git a/python/tests/async/env_vars/test_r.py b/python/tests/async/env_vars/test_r.py index 8864899b..80074334 100644 --- a/python/tests/async/env_vars/test_r.py +++ b/python/tests/async/env_vars/test_r.py @@ -14,26 +14,22 @@ async def test_env_vars_on_sandbox(): finally: await sandbox.kill() -async def test_env_vars_per_execution(): - sandbox = await AsyncSandbox.create() - try: - result = await sandbox.run_code( - 'Sys.getenv("FOO")', - envs={"FOO": "bar"}, - language="r" - ) - - result_empty = await sandbox.run_code( - 'Sys.getenv("FOO", unset = "default")', - language="r" - ) - - assert result.text is not None - assert result.text.strip() == '[1] "bar"' - assert result_empty.text is not None - assert result_empty.text.strip() == '[1] "default"' - finally: - await sandbox.kill() +async def test_env_vars_per_execution(sandbox: AsyncSandbox): + result = await sandbox.run_code( + 'Sys.getenv("FOO")', + envs={"FOO": "bar"}, + language="r" + ) + + result_empty = await sandbox.run_code( + 'Sys.getenv("FOO", unset = "default")', + language="r" + ) + + assert result.text is not None + assert result.text.strip() == '[1] "bar"' + assert result_empty.text is not None + assert result_empty.text.strip() == '[1] "default"' @pytest.mark.skip_debug() async def test_env_vars_overwrite(): diff --git a/python/tests/sync/env_vars/test_bash.py b/python/tests/sync/env_vars/test_bash.py index 45411eeb..ed66b479 100644 --- a/python/tests/sync/env_vars/test_bash.py +++ b/python/tests/sync/env_vars/test_bash.py @@ -9,28 +9,24 @@ def test_env_vars_on_sandbox(): "echo $TEST_ENV_VAR", language="bash" ) - assert result.results[0].text.strip() == "supertest" + assert result.logs.stdout[0] == "supertest\n" finally: sandbox.kill() -def test_env_vars_per_execution(): - sandbox = Sandbox() - try: - result = sandbox.run_code( - "echo $FOO", - envs={"FOO": "bar"}, - language="bash" - ) - - result_empty = sandbox.run_code( - "echo ${FOO:-default}", - language="bash" - ) - - assert result.results[0].text.strip() == "bar" - assert result_empty.results[0].text.strip() == "default" - finally: - sandbox.kill() +def test_env_vars_per_execution(sandbox: Sandbox): + result = sandbox.run_code( + "echo $FOO", + envs={"FOO": "bar"}, + language="bash" + ) + + result_empty = sandbox.run_code( + "echo ${FOO:-default}", + language="bash" + ) + + assert result.logs.stdout[0] == "bar\n" + assert result_empty.logs.stdout[0] == "default\n" @pytest.mark.skip_debug() def test_env_vars_overwrite(): @@ -41,6 +37,6 @@ def test_env_vars_overwrite(): language="bash", envs={"TEST_ENV_VAR": "overwrite"} ) - assert result.results[0].text.strip() == "overwrite" + assert result.logs.stdout[0] == "overwrite\n" finally: sandbox.kill() From 3bf7cdbe1f9e8e1d35e5b7f54dc359d0df99bebe Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 22:22:06 +0200 Subject: [PATCH 16/18] testing resetting to default in case of override --- js/tests/env_vars/bash.test.ts | 8 ++++++++ js/tests/env_vars/deno.test.ts | 8 ++++++++ js/tests/env_vars/java.test.ts | 8 ++++++++ js/tests/env_vars/js.test.ts | 8 ++++++++ js/tests/env_vars/python.test.ts | 8 ++++++++ js/tests/env_vars/r.test.ts | 5 +++++ python/tests/async/env_vars/test_bash.py | 5 +++++ python/tests/async/env_vars/test_deno.py | 6 ++++++ python/tests/async/env_vars/test_java.py | 6 ++++++ python/tests/async/env_vars/test_js.py | 6 ++++++ python/tests/async/env_vars/test_python.py | 6 ++++++ python/tests/async/env_vars/test_r.py | 6 ++++++ python/tests/sync/env_vars/test_bash.py | 5 +++++ python/tests/sync/env_vars/test_deno.py | 5 +++++ python/tests/sync/env_vars/test_java.py | 5 +++++ python/tests/sync/env_vars/test_js.py | 5 +++++ python/tests/sync/env_vars/test_python.py | 5 +++++ python/tests/sync/env_vars/test_r.py | 5 +++++ 18 files changed, 110 insertions(+) diff --git a/js/tests/env_vars/bash.test.ts b/js/tests/env_vars/bash.test.ts index 7ff8ea84..59c8aada 100644 --- a/js/tests/env_vars/bash.test.ts +++ b/js/tests/env_vars/bash.test.ts @@ -54,7 +54,15 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) + 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() } diff --git a/js/tests/env_vars/deno.test.ts b/js/tests/env_vars/deno.test.ts index d95be1ec..02fa3491 100644 --- a/js/tests/env_vars/deno.test.ts +++ b/js/tests/env_vars/deno.test.ts @@ -54,7 +54,15 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) + const result_global_default = await sandbox.runCode( + `Deno.env.get('TEST_ENV_VAR')`, + { + language: 'deno', + } + ) + expect(result.results[0]?.text.trim()).toEqual('overwrite') + expect(result_global_default.results[0]?.text.trim()).toEqual('supertest') } finally { await sandbox.kill() } diff --git a/js/tests/env_vars/java.test.ts b/js/tests/env_vars/java.test.ts index fad4ff68..d9294deb 100644 --- a/js/tests/env_vars/java.test.ts +++ b/js/tests/env_vars/java.test.ts @@ -57,7 +57,15 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) + 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() } diff --git a/js/tests/env_vars/js.test.ts b/js/tests/env_vars/js.test.ts index ce24bf0d..74c63a72 100644 --- a/js/tests/env_vars/js.test.ts +++ b/js/tests/env_vars/js.test.ts @@ -54,7 +54,15 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) + 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() } diff --git a/js/tests/env_vars/python.test.ts b/js/tests/env_vars/python.test.ts index 912f9d60..b935bcb3 100644 --- a/js/tests/env_vars/python.test.ts +++ b/js/tests/env_vars/python.test.ts @@ -54,7 +54,15 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { } ) + 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() } diff --git a/js/tests/env_vars/r.test.ts b/js/tests/env_vars/r.test.ts index 381acf18..88856fb2 100644 --- a/js/tests/env_vars/r.test.ts +++ b/js/tests/env_vars/r.test.ts @@ -48,7 +48,12 @@ sandboxTest.skipIf(isDebug)('env vars overwrite', async () => { envs: { TEST_ENV_VAR: 'overwrite' }, }) + const result_global_default = await sandbox.runCode(`Sys.getenv("TEST_ENV_VAR")`, { + language: 'r', + }) + expect(result.results[0]?.text.trim()).toEqual(`[1] "overwrite"`) + expect(result_global_default.results[0]?.text.trim()).toEqual(`[1] "supertest"`) } finally { await sandbox.kill() } diff --git a/python/tests/async/env_vars/test_bash.py b/python/tests/async/env_vars/test_bash.py index 4674346f..78b303b8 100644 --- a/python/tests/async/env_vars/test_bash.py +++ b/python/tests/async/env_vars/test_bash.py @@ -38,6 +38,11 @@ async def test_env_vars_overwrite(): language="bash", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash" + ) assert result.logs.stdout[0] == "overwrite\n" + assert result_global_default.logs.stdout[0] == "supertest\n" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_deno.py b/python/tests/async/env_vars/test_deno.py index ce20f369..7df82d21 100644 --- a/python/tests/async/env_vars/test_deno.py +++ b/python/tests/async/env_vars/test_deno.py @@ -40,7 +40,13 @@ async def test_env_vars_overwrite(): language="deno", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno" + ) assert result.text is not None assert result.text.strip() == "overwrite" + assert result_global_default.text is not None + assert result_global_default.text.strip() == "supertest" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_java.py b/python/tests/async/env_vars/test_java.py index 7475637a..d48c95e9 100644 --- a/python/tests/async/env_vars/test_java.py +++ b/python/tests/async/env_vars/test_java.py @@ -40,7 +40,13 @@ async def test_env_vars_overwrite(): language="java", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + 'System.getProperty("TEST_ENV_VAR")', + language="java" + ) assert result.text is not None assert result.text.strip() == "overwrite" + assert result_global_default.text is not None + assert result_global_default.text.strip() == "supertest" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_js.py b/python/tests/async/env_vars/test_js.py index 6c8f6e06..884f9934 100644 --- a/python/tests/async/env_vars/test_js.py +++ b/python/tests/async/env_vars/test_js.py @@ -40,7 +40,13 @@ async def test_env_vars_overwrite(): language="javascript", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript" + ) assert result.text is not None assert result.text.strip() == "overwrite" + assert result_global_default.text is not None + assert result_global_default.text.strip() == "supertest" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_python.py b/python/tests/async/env_vars/test_python.py index b8c0e8d7..0302e197 100644 --- a/python/tests/async/env_vars/test_python.py +++ b/python/tests/async/env_vars/test_python.py @@ -40,7 +40,13 @@ async def test_env_vars_overwrite(): language="python", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + "import os; os.getenv('TEST_ENV_VAR')", + language="python" + ) assert result.text is not None assert result.text.strip() == "overwrite" + assert result_global_default.text is not None + assert result_global_default.text.strip() == "supertest" finally: await sandbox.kill() diff --git a/python/tests/async/env_vars/test_r.py b/python/tests/async/env_vars/test_r.py index 80074334..ee551d85 100644 --- a/python/tests/async/env_vars/test_r.py +++ b/python/tests/async/env_vars/test_r.py @@ -40,7 +40,13 @@ async def test_env_vars_overwrite(): language="r", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = await sandbox.run_code( + 'Sys.getenv("TEST_ENV_VAR")', + language="r" + ) assert result.text is not None assert result.text.strip() == '[1] "overwrite"' + assert result_global_default.text is not None + assert result_global_default.text.strip() == "supertest" finally: await sandbox.kill() diff --git a/python/tests/sync/env_vars/test_bash.py b/python/tests/sync/env_vars/test_bash.py index ed66b479..1fec84c1 100644 --- a/python/tests/sync/env_vars/test_bash.py +++ b/python/tests/sync/env_vars/test_bash.py @@ -37,6 +37,11 @@ def test_env_vars_overwrite(): language="bash", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + "echo $TEST_ENV_VAR", + language="bash" + ) assert result.logs.stdout[0] == "overwrite\n" + assert result_global_default.logs.stdout[0] == "supertest\n" finally: sandbox.kill() diff --git a/python/tests/sync/env_vars/test_deno.py b/python/tests/sync/env_vars/test_deno.py index a7503d51..03ba4d0c 100644 --- a/python/tests/sync/env_vars/test_deno.py +++ b/python/tests/sync/env_vars/test_deno.py @@ -41,6 +41,11 @@ def test_env_vars_overwrite(): language="deno", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + "const x = Deno.env.get('TEST_ENV_VAR'); x", + language="deno" + ) assert result.results[0].text.strip() == "overwrite" + assert result_global_default.results[0].text.strip() == "supertest" finally: sandbox.kill() diff --git a/python/tests/sync/env_vars/test_java.py b/python/tests/sync/env_vars/test_java.py index 9e3bc168..8e802283 100644 --- a/python/tests/sync/env_vars/test_java.py +++ b/python/tests/sync/env_vars/test_java.py @@ -41,6 +41,11 @@ def test_env_vars_overwrite(): language="java", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + 'System.getProperty("TEST_ENV_VAR")', + language="java" + ) assert result.results[0].text.strip() == "overwrite" + assert result_global_default.results[0].text.strip() == "supertest" finally: sandbox.kill() diff --git a/python/tests/sync/env_vars/test_js.py b/python/tests/sync/env_vars/test_js.py index 80ed0991..3c019e7e 100644 --- a/python/tests/sync/env_vars/test_js.py +++ b/python/tests/sync/env_vars/test_js.py @@ -41,6 +41,11 @@ def test_env_vars_overwrite(): language="javascript", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + "process.env.TEST_ENV_VAR", + language="javascript" + ) assert result.results[0].text.strip() == "overwrite" + assert result_global_default.results[0].text.strip() == "supertest" finally: sandbox.kill() diff --git a/python/tests/sync/env_vars/test_python.py b/python/tests/sync/env_vars/test_python.py index 4c46f482..548dc075 100644 --- a/python/tests/sync/env_vars/test_python.py +++ b/python/tests/sync/env_vars/test_python.py @@ -41,6 +41,11 @@ def test_env_vars_overwrite(): language="python", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + "import os; os.getenv('TEST_ENV_VAR')", + language="python" + ) assert result.results[0].text.strip() == "overwrite" + assert result_global_default.results[0].text.strip() == "supertest" finally: sandbox.kill() diff --git a/python/tests/sync/env_vars/test_r.py b/python/tests/sync/env_vars/test_r.py index 76136e78..a8ad98b0 100644 --- a/python/tests/sync/env_vars/test_r.py +++ b/python/tests/sync/env_vars/test_r.py @@ -41,6 +41,11 @@ def test_env_vars_overwrite(): language="r", envs={"TEST_ENV_VAR": "overwrite"} ) + result_global_default = sandbox.run_code( + "Sys.getenv('TEST_ENV_VAR')", + language="r" + ) assert result.results[0].text.strip() == '[1] "overwrite"' + assert result_global_default.results[0].text.strip() == '[1] "supertest"' finally: sandbox.kill() From 7f9b10f35b862bb9a0da4e2718d4aa0250b7edce Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 22:27:35 +0200 Subject: [PATCH 17/18] fix regression in python test --- template/server/messaging.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/template/server/messaging.py b/template/server/messaging.py index 5ce88db5..0b37f4f5 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -142,7 +142,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): env_commands = [] for k, v in env_vars.items(): if self.language == "python": - env_commands.append(f"%env {k}={v}") + env_commands.append(f"import os; os.environ['{k}'] = '{v}'") elif self.language in ["javascript", "typescript"]: env_commands.append(f"process.env['{k}'] = '{v}'") elif self.language == "deno": @@ -191,7 +191,7 @@ async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): remove_commands = [] for key in vars_to_remove: if self.language == "python": - remove_commands.append(f"%env -u {key}") + remove_commands.append(f"import os; del os.environ['{key}']") elif self.language in ["javascript", "typescript"]: remove_commands.append(f"delete process.env['{key}']") elif self.language == "deno": From 76f15f803310b3d74a9086c584dd80809b3e1f95 Mon Sep 17 00:00:00 2001 From: Mish <10400064+mishushakov@users.noreply.github.com> Date: Fri, 6 Jun 2025 23:27:56 +0200 Subject: [PATCH 18/18] async http client for requesting env vars --- template/server/contexts.py | 2 +- template/server/envs.py | 12 ++++++++---- template/server/messaging.py | 2 +- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/template/server/contexts.py b/template/server/contexts.py index 82e0c007..e6f129e0 100644 --- a/template/server/contexts.py +++ b/template/server/contexts.py @@ -52,7 +52,7 @@ async def create_context(client, websockets: dict, language: str, cwd: str) -> C session_data = response.json() session_id = session_data["id"] context_id = session_data["kernel"]["id"] - global_env_vars = get_envs() + global_env_vars = await get_envs() logger.debug(f"Created context {context_id}") diff --git a/template/server/envs.py b/template/server/envs.py index a8f882af..2456f74d 100644 --- a/template/server/envs.py +++ b/template/server/envs.py @@ -1,12 +1,16 @@ import os -import requests +import httpx LOCAL = os.getenv("E2B_LOCAL", False) ENVD_PORT = 49983 -def get_envs() -> dict: +async def get_envs() -> dict: if LOCAL: - return {} - return requests.get(f"http://localhost:{ENVD_PORT}/envs").json() + return { + "E2B_TEST_VARIABLE": "true" + } + async with httpx.AsyncClient() as client: + response = await client.get(f"http://localhost:{ENVD_PORT}/envs") + return response.json() diff --git a/template/server/messaging.py b/template/server/messaging.py index 0b37f4f5..78882c51 100644 --- a/template/server/messaging.py +++ b/template/server/messaging.py @@ -167,7 +167,7 @@ async def set_env_vars(self, env_vars: Dict[StrictStr, str]): raise ExecutionError(f"Error during execution: {item}") async def reset_env_vars(self, env_vars: Dict[StrictStr, str]): - global_env_vars = get_envs() + global_env_vars = await get_envs() # Create a dict of vars to reset and a list of vars to remove vars_to_reset = {}