Extend `evil` test suite to account for VFS writes

[Sl1mb0]

Extend the evil test suite to include tests that will perform 'evil' writes to the host via the guest. We currently only account for reads, so we should account for writes too.

[crepererum]

We currently only account for reads, so we should account for writes too.

I'm not against extending the test suite, but this statement is factually wrong:

datafusion-udf-wasm/guests/evil/src/fs.rs

Lines 80 to 239 in 8c49c2f

	/// Returns our evil UDFs.
	///
	/// The passed `source` is ignored.
	#[expect(clippy::unnecessary_wraps, reason = "public API through export! macro")]
	pub(crate) fn udfs(_source: String) -> DataFusionResult<Vec<Arc<dyn ScalarUDFImpl>>> {
	Ok(vec![
	Arc::new(String1Udf::new("canonicalize", |path| {
	std::fs::canonicalize(path)
	.map(|p| p.display().to_string())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String2Udf::new("copy", |from, to| {
	std::fs::copy(from, to)
	.map(|n_bytes| n_bytes.to_string())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("create_dir", |path| {
	std::fs::create_dir(path)
	.map(|()| "created".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("exists", |path| {
	std::fs::exists(path)
	.map(|b| b.to_string())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String2Udf::new("hard_link", |from, to| {
	std::fs::hard_link(from, to)
	.map(|_| "linked".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("metadata", |path| {
	std::fs::metadata(path)
	.map(|_| "got data".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_append", |path| {
	std::fs::File::options()
	.append(true)
	.create(false)
	.create_new(false)
	.read(false)
	.truncate(false)
	.write(false)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_create", |path| {
	std::fs::File::options()
	.append(false)
	.create(true)
	.create_new(false)
	.read(false)
	.truncate(false)
	.write(true)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_create_new", |path| {
	std::fs::File::options()
	.append(false)
	.create(false)
	.create_new(true)
	.read(false)
	.truncate(false)
	.write(true)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_read", |path| {
	std::fs::File::options()
	.append(false)
	.create(false)
	.create_new(false)
	.read(true)
	.truncate(false)
	.write(false)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_truncate", |path| {
	std::fs::File::options()
	.append(false)
	.create(false)
	.create_new(false)
	.read(false)
	.truncate(true)
	.write(true)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("open_write", |path| {
	std::fs::File::options()
	.append(false)
	.create(false)
	.create_new(false)
	.read(false)
	.truncate(false)
	.write(true)
	.open(path)
	.map(|_| "opened".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("read_dir", |path| {
	std::fs::read_dir(path)
	.map(|it| {
	let entries = it
	.map(|res| match res {
	Ok(entry) => format!("OK: {}", entry.path().display()),
	Err(e) => format!("ERR: {e}"),
	})
	.collect::<Vec<_>>();
	if entries.is_empty() {
	"<EMPTY>".to_owned()
	} else {
	entries.join(",")
	}
	})
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("read_link", |path| {
	std::fs::read_link(path)
	.map(|p| p.display().to_string())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("remove_dir", |path| {
	std::fs::remove_dir(path)
	.map(|()| "removed".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("remove_file", |path| {
	std::fs::remove_file(path)
	.map(|()| "removed".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String2Udf::new("rename", |from, to| {
	std::fs::rename(from, to)
	.map(|()| "renamed".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("set_permissions", |path| {
	// We need some pre-existing file to get the opaque permissions object first. The root of the filesystem
	// should always be available.
	let perm = std::fs::metadata("/").unwrap().permissions();
	std::fs::set_permissions(path, perm)
	.map(|()| "set".to_owned())
	.map_err(|e| e.to_string())
	})),
	Arc::new(String1Udf::new("symlink_metadata", |path| {
	std::fs::symlink_metadata(path)
	.map(|_| "got data".to_owned())
	.map_err(|e| e.to_string())
	})),
	])
	}