refactor: clean up execution_spec

Cargo.toml

@@ -146,6 +146,8 @@ convert_case = "0.6.0"
 rand = "0.8.5"
 tailcall-macros = { path = "tailcall-macros" }
 tonic-types = "0.11.0"
+datatest-stable = "0.2.7"
+tokio-test = "0.4.4"
 
 
 [dev-dependencies]
@@ -244,3 +246,8 @@ harness = false
 [[bench]]
 name = "protobuf_convert_output"
 harness = false
+
+[[test]]
+name = "execution_spec"
+harness = false
+

tests/core/env.rs

@@ -0,0 +1,23 @@
+extern crate core;
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+
+use tailcall::EnvIO;
+
+#[derive(Clone)]
+pub struct TestEnvIO {
+    vars: HashMap<String, String>,
+}
+
+impl EnvIO for TestEnvIO {
+    fn get(&self, key: &str) -> Option<Cow<'_, str>> {
+        self.vars.get(key).map(Cow::from)
+    }
+}
+
+impl TestEnvIO {
+    pub fn init(vars: Option<HashMap<String, String>>) -> Self {
+        Self { vars: vars.unwrap_or_default() }
+    }
+}

tests/core/file.rs

@@ -0,0 +1,67 @@
+extern crate core;
+
+use std::path::PathBuf;
+
+use anyhow::{anyhow, Context};
+use tailcall::FileIO;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+use super::runtime::ExecutionSpec;
+pub struct MockFileSystem {
+    spec: ExecutionSpec,
+}
+
+impl MockFileSystem {
+    pub fn new(spec: ExecutionSpec) -> MockFileSystem {
+        MockFileSystem { spec }
+    }
+}
+
+#[async_trait::async_trait]
+impl FileIO for MockFileSystem {
+    async fn write<'a>(&'a self, _path: &'a str, _content: &'a [u8]) -> anyhow::Result<()> {
+        Err(anyhow!("Cannot write to a file in an execution spec"))
+    }
+
+    async fn read<'a>(&'a self, path: &'a str) -> anyhow::Result<String> {
+        let base = PathBuf::from(path);
+        let path = base
+            .file_name()
+            .context("Invalid file path")?
+            .to_str()
+            .context("Invalid OsString")?;
+        match self.spec.files.get(path) {
+            Some(x) => Ok(x.to_owned()),
+            None => Err(anyhow!("No such file or directory (os error 2)")),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct TestFileIO {}
+
+impl TestFileIO {
+    pub fn init() -> Self {
+        TestFileIO {}
+    }
+}
+
+#[async_trait::async_trait]
+impl FileIO for TestFileIO {
+    async fn write<'a>(&'a self, path: &'a str, content: &'a [u8]) -> anyhow::Result<()> {
+        let mut file = tokio::fs::File::create(path).await?;
+        file.write_all(content)
+            .await
+            .map_err(|e| anyhow!("{}", e))?;
+        Ok(())
+    }
+
+    async fn read<'a>(&'a self, path: &'a str) -> anyhow::Result<String> {
+        let mut file = tokio::fs::File::open(path).await?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)
+            .await
+            .map_err(|e| anyhow!("{}", e))?;
+        Ok(String::from_utf8(buffer)?)
+    }
+}