618 lines
20 KiB
Rust
618 lines
20 KiB
Rust
//! Integration tests for runtime environment and dependency isolation
|
|
//!
|
|
//! Tests the end-to-end flow of creating isolated runtime environments
|
|
//! for packs using the ProcessRuntime configuration-driven approach.
|
|
//!
|
|
//! Environment directories are placed at:
|
|
//! {runtime_envs_dir}/{pack_ref}/{runtime_name}
|
|
//! e.g., /tmp/.../runtime_envs/testpack/python
|
|
//! This keeps the pack directory clean and read-only.
|
|
|
|
use attune_common::models::runtime::{
|
|
DependencyConfig, EnvironmentConfig, InterpreterConfig, RuntimeExecutionConfig,
|
|
};
|
|
use attune_worker::runtime::process::ProcessRuntime;
|
|
use attune_worker::runtime::ExecutionContext;
|
|
use attune_worker::runtime::Runtime;
|
|
use attune_worker::runtime::{OutputFormat, ParameterDelivery, ParameterFormat};
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use tempfile::TempDir;
|
|
|
|
fn make_python_config() -> RuntimeExecutionConfig {
|
|
RuntimeExecutionConfig {
|
|
interpreter: InterpreterConfig {
|
|
binary: "python3".to_string(),
|
|
args: vec!["-u".to_string()],
|
|
file_extension: Some(".py".to_string()),
|
|
},
|
|
environment: Some(EnvironmentConfig {
|
|
env_type: "virtualenv".to_string(),
|
|
dir_name: ".venv".to_string(),
|
|
create_command: vec![
|
|
"python3".to_string(),
|
|
"-m".to_string(),
|
|
"venv".to_string(),
|
|
"{env_dir}".to_string(),
|
|
],
|
|
interpreter_path: Some("{env_dir}/bin/python3".to_string()),
|
|
}),
|
|
dependencies: Some(DependencyConfig {
|
|
manifest_file: "requirements.txt".to_string(),
|
|
install_command: vec![
|
|
"{interpreter}".to_string(),
|
|
"-m".to_string(),
|
|
"pip".to_string(),
|
|
"install".to_string(),
|
|
"-r".to_string(),
|
|
"{manifest_path}".to_string(),
|
|
],
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn make_shell_config() -> RuntimeExecutionConfig {
|
|
RuntimeExecutionConfig {
|
|
interpreter: InterpreterConfig {
|
|
binary: "/bin/bash".to_string(),
|
|
args: vec![],
|
|
file_extension: Some(".sh".to_string()),
|
|
},
|
|
environment: None,
|
|
dependencies: None,
|
|
}
|
|
}
|
|
|
|
fn make_context(action_ref: &str, entry_point: &str, runtime_name: &str) -> ExecutionContext {
|
|
ExecutionContext {
|
|
execution_id: 1,
|
|
action_ref: action_ref.to_string(),
|
|
parameters: HashMap::new(),
|
|
env: HashMap::new(),
|
|
secrets: HashMap::new(),
|
|
timeout: Some(30),
|
|
working_dir: None,
|
|
entry_point: entry_point.to_string(),
|
|
code: None,
|
|
code_path: None,
|
|
runtime_name: Some(runtime_name.to_string()),
|
|
max_stdout_bytes: 10 * 1024 * 1024,
|
|
max_stderr_bytes: 10 * 1024 * 1024,
|
|
parameter_delivery: ParameterDelivery::default(),
|
|
parameter_format: ParameterFormat::default(),
|
|
output_format: OutputFormat::default(),
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_python_venv_creation_via_process_runtime() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup the pack environment (creates venv at external location)
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to create venv environment");
|
|
|
|
// Verify venv was created at the external runtime_envs location
|
|
assert!(env_dir.exists(), "Virtualenv directory should exist at external location");
|
|
|
|
let venv_python = env_dir.join("bin").join("python3");
|
|
assert!(
|
|
venv_python.exists(),
|
|
"Virtualenv python3 binary should exist"
|
|
);
|
|
|
|
// Verify pack directory was NOT modified
|
|
assert!(
|
|
!pack_dir.join(".venv").exists(),
|
|
"Pack directory should not contain .venv — environments are external"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_venv_creation_is_idempotent() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Create environment first time
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to create environment");
|
|
|
|
assert!(env_dir.exists());
|
|
|
|
// Create environment second time — should succeed without error
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Second setup should succeed (idempotent)");
|
|
|
|
assert!(env_dir.exists());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_dependency_installation() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
// Write a requirements.txt with a simple, fast-to-install package
|
|
std::fs::write(
|
|
pack_dir.join("requirements.txt"),
|
|
"pip>=21.0\n", // pip is already installed, so this is fast
|
|
)
|
|
.unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup creates the venv and installs dependencies
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to setup environment with dependencies");
|
|
|
|
assert!(env_dir.exists());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_no_environment_for_shell_runtime() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("shell");
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"shell".to_string(),
|
|
make_shell_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Shell runtime has no environment config — should be a no-op
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Shell setup should succeed (no environment to create)");
|
|
|
|
// No environment should exist
|
|
assert!(!env_dir.exists());
|
|
assert!(!pack_dir.join(".venv").exists());
|
|
assert!(!pack_dir.join("node_modules").exists());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_pack_has_dependencies_detection() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// No requirements.txt yet
|
|
assert!(
|
|
!runtime.pack_has_dependencies(&pack_dir),
|
|
"Should not detect dependencies without manifest file"
|
|
);
|
|
|
|
// Create requirements.txt
|
|
std::fs::write(pack_dir.join("requirements.txt"), "requests>=2.28.0\n").unwrap();
|
|
|
|
assert!(
|
|
runtime.pack_has_dependencies(&pack_dir),
|
|
"Should detect dependencies when manifest file exists"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_environment_exists_detection() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// No venv yet — environment_exists uses pack_ref string
|
|
assert!(
|
|
!runtime.environment_exists("testpack"),
|
|
"Environment should not exist before setup"
|
|
);
|
|
|
|
// Create the venv
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to create environment");
|
|
|
|
assert!(
|
|
runtime.environment_exists("testpack"),
|
|
"Environment should exist after setup"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_multiple_pack_isolation() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
|
|
let pack_a_dir = packs_base_dir.join("pack_a");
|
|
let pack_b_dir = packs_base_dir.join("pack_b");
|
|
std::fs::create_dir_all(&pack_a_dir).unwrap();
|
|
std::fs::create_dir_all(&pack_b_dir).unwrap();
|
|
|
|
let env_dir_a = runtime_envs_dir.join("pack_a").join("python");
|
|
let env_dir_b = runtime_envs_dir.join("pack_b").join("python");
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup environments for two different packs
|
|
runtime
|
|
.setup_pack_environment(&pack_a_dir, &env_dir_a)
|
|
.await
|
|
.expect("Failed to setup pack_a");
|
|
|
|
runtime
|
|
.setup_pack_environment(&pack_b_dir, &env_dir_b)
|
|
.await
|
|
.expect("Failed to setup pack_b");
|
|
|
|
// Each pack should have its own venv at the external location
|
|
assert!(env_dir_a.exists(), "pack_a should have its own venv");
|
|
assert!(env_dir_b.exists(), "pack_b should have its own venv");
|
|
assert_ne!(env_dir_a, env_dir_b, "Venvs should be in different directories");
|
|
|
|
// Pack directories should remain clean
|
|
assert!(!pack_a_dir.join(".venv").exists(), "pack_a dir should not contain .venv");
|
|
assert!(!pack_b_dir.join(".venv").exists(), "pack_b dir should not contain .venv");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_execute_python_action_with_venv() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
let actions_dir = pack_dir.join("actions");
|
|
std::fs::create_dir_all(&actions_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
// Write a Python script
|
|
std::fs::write(
|
|
actions_dir.join("hello.py"),
|
|
r#"
|
|
import sys
|
|
print(f"Python from: {sys.executable}")
|
|
print("Hello from venv action!")
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup the venv first
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to setup venv");
|
|
|
|
// Now execute the action
|
|
let mut context = make_context("testpack.hello", "hello.py", "python");
|
|
context.code_path = Some(actions_dir.join("hello.py"));
|
|
|
|
let result = runtime.execute(context).await.unwrap();
|
|
|
|
assert_eq!(result.exit_code, 0, "Action should succeed");
|
|
assert!(
|
|
result.stdout.contains("Hello from venv action!"),
|
|
"Should see output from action. Got: {}",
|
|
result.stdout
|
|
);
|
|
// Verify it's using the venv Python (at external runtime_envs location)
|
|
assert!(
|
|
result.stdout.contains("runtime_envs"),
|
|
"Should be using the venv python from external runtime_envs dir. Got: {}",
|
|
result.stdout
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_execute_shell_action_no_venv() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
let actions_dir = pack_dir.join("actions");
|
|
std::fs::create_dir_all(&actions_dir).unwrap();
|
|
|
|
std::fs::write(
|
|
actions_dir.join("greet.sh"),
|
|
"#!/bin/bash\necho 'Hello from shell!'",
|
|
)
|
|
.unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"shell".to_string(),
|
|
make_shell_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
let mut context = make_context("testpack.greet", "greet.sh", "shell");
|
|
context.code_path = Some(actions_dir.join("greet.sh"));
|
|
|
|
let result = runtime.execute(context).await.unwrap();
|
|
|
|
assert_eq!(result.exit_code, 0);
|
|
assert!(result.stdout.contains("Hello from shell!"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_working_directory_is_pack_dir() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
let actions_dir = pack_dir.join("actions");
|
|
std::fs::create_dir_all(&actions_dir).unwrap();
|
|
|
|
// Script that prints the working directory
|
|
std::fs::write(actions_dir.join("cwd.sh"), "#!/bin/bash\npwd").unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"shell".to_string(),
|
|
make_shell_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
let mut context = make_context("testpack.cwd", "cwd.sh", "shell");
|
|
context.code_path = Some(actions_dir.join("cwd.sh"));
|
|
|
|
let result = runtime.execute(context).await.unwrap();
|
|
|
|
assert_eq!(result.exit_code, 0);
|
|
let output_path = result.stdout.trim();
|
|
assert_eq!(
|
|
output_path,
|
|
pack_dir.to_string_lossy().as_ref(),
|
|
"Working directory should be the pack directory"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_interpreter_resolution_with_venv() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
let config = make_python_config();
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
config.clone(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Before venv creation — should resolve to system python
|
|
let interpreter = config.resolve_interpreter_with_env(&pack_dir, Some(&env_dir));
|
|
assert_eq!(
|
|
interpreter,
|
|
PathBuf::from("python3"),
|
|
"Without venv, should use system python"
|
|
);
|
|
|
|
// Create venv at external location
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Failed to create venv");
|
|
|
|
// After venv creation — should resolve to venv python at external location
|
|
let interpreter = config.resolve_interpreter_with_env(&pack_dir, Some(&env_dir));
|
|
let expected_venv_python = env_dir.join("bin").join("python3");
|
|
assert_eq!(
|
|
interpreter, expected_venv_python,
|
|
"With venv, should use venv python from external runtime_envs dir"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_skip_deps_install_without_manifest() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let packs_base_dir = temp_dir.path().join("packs");
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
let pack_dir = packs_base_dir.join("testpack");
|
|
std::fs::create_dir_all(&pack_dir).unwrap();
|
|
|
|
let env_dir = runtime_envs_dir.join("testpack").join("python");
|
|
|
|
// No requirements.txt — install_dependencies should be a no-op
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
packs_base_dir,
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup should still create the venv but skip dependency installation
|
|
runtime
|
|
.setup_pack_environment(&pack_dir, &env_dir)
|
|
.await
|
|
.expect("Setup should succeed without manifest");
|
|
|
|
assert!(
|
|
env_dir.exists(),
|
|
"Venv should still be created at external location"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_runtime_config_matches_file_extension() {
|
|
let config = make_python_config();
|
|
|
|
assert!(config.matches_file_extension(std::path::Path::new("hello.py")));
|
|
assert!(config.matches_file_extension(std::path::Path::new(
|
|
"/opt/attune/packs/mypack/actions/script.py"
|
|
)));
|
|
assert!(!config.matches_file_extension(std::path::Path::new("hello.sh")));
|
|
assert!(!config.matches_file_extension(std::path::Path::new("hello.js")));
|
|
|
|
let shell_config = make_shell_config();
|
|
assert!(shell_config.matches_file_extension(std::path::Path::new("run.sh")));
|
|
assert!(!shell_config.matches_file_extension(std::path::Path::new("run.py")));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_dependency_spec_builder_still_works() {
|
|
// The DependencySpec types are still available for generic use
|
|
use attune_worker::runtime::DependencySpec;
|
|
|
|
let spec = DependencySpec::new("python")
|
|
.with_dependency("requests==2.28.0")
|
|
.with_dependency("flask>=2.0.0")
|
|
.with_version_range(Some("3.8".to_string()), Some("3.11".to_string()));
|
|
|
|
assert_eq!(spec.runtime, "python");
|
|
assert_eq!(spec.dependencies.len(), 2);
|
|
assert!(spec.has_dependencies());
|
|
assert_eq!(spec.min_version, Some("3.8".to_string()));
|
|
assert_eq!(spec.max_version, Some("3.11".to_string()));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_process_runtime_setup_and_validate() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
let runtime_envs_dir = temp_dir.path().join("runtime_envs");
|
|
|
|
let shell_runtime = ProcessRuntime::new(
|
|
"shell".to_string(),
|
|
make_shell_config(),
|
|
temp_dir.path().to_path_buf(),
|
|
runtime_envs_dir.clone(),
|
|
);
|
|
|
|
// Setup and validate should succeed for shell
|
|
shell_runtime.setup().await.unwrap();
|
|
shell_runtime.validate().await.unwrap();
|
|
|
|
let python_runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
temp_dir.path().to_path_buf(),
|
|
runtime_envs_dir,
|
|
);
|
|
|
|
// Setup and validate should succeed for python (warns if not available)
|
|
python_runtime.setup().await.unwrap();
|
|
python_runtime.validate().await.unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_can_execute_by_runtime_name() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
temp_dir.path().to_path_buf(),
|
|
temp_dir.path().join("runtime_envs"),
|
|
);
|
|
|
|
let context = make_context("mypack.hello", "hello.py", "python");
|
|
assert!(runtime.can_execute(&context));
|
|
|
|
let wrong_context = make_context("mypack.hello", "hello.py", "shell");
|
|
assert!(!runtime.can_execute(&wrong_context));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_can_execute_by_file_extension() {
|
|
let temp_dir = TempDir::new().unwrap();
|
|
|
|
let runtime = ProcessRuntime::new(
|
|
"python".to_string(),
|
|
make_python_config(),
|
|
temp_dir.path().to_path_buf(),
|
|
temp_dir.path().join("runtime_envs"),
|
|
);
|
|
|
|
let mut context = make_context("mypack.hello", "hello.py", "");
|
|
context.runtime_name = None;
|
|
context.code_path = Some(PathBuf::from("/tmp/packs/mypack/actions/hello.py"));
|
|
assert!(runtime.can_execute(&context));
|
|
|
|
context.code_path = Some(PathBuf::from("/tmp/packs/mypack/actions/hello.sh"));
|
|
context.entry_point = "hello.sh".to_string();
|
|
assert!(!runtime.can_execute(&context));
|
|
}
|