Struct aws_types::os_shim_internal::Fs

pub struct Fs(/* private fields */);

File system abstraction

Simple abstraction enabling in-memory mocking of the file system

Examples

Construct a file system which delegates to std::fs:

let fs = aws_types::os_shim_internal::Fs::real();

Construct an in-memory file system for testing:

use std::collections::HashMap;
let fs = aws_types::os_shim_internal::Fs::from_map({
    let mut map = HashMap::new();
    map.insert("/home/.aws/config".to_string(), "[default]\nregion = us-east-1");
    map
});

Implementations

impl Fs

pub fn real() -> Self

Create Fs representing a real file system.

pub fn from_raw_map(fs: HashMap<OsString, Vec<u8>>) -> Self

Create Fs from a map of OsString to Vec<u8>.

pub fn from_map(data: HashMap<String, impl Into<Vec<u8>>>) -> Self

Create Fs from a map of String to Vec<u8>.

pub fn from_test_dir( test_directory: impl Into<PathBuf>, namespaced_to: impl Into<PathBuf> ) -> Self

Create a test filesystem rooted in real files

Creates a test filesystem from the contents of test_directory rooted into namespaced_to.

Example: Given:

$ ls
./my-test-dir/aws-config
./my-test-dir/aws-config/config
$ cat ./my-test-dir/aws-config/config
test-config

use aws_types::os_shim_internal::{Env, Fs};
let env = Env::from_slice(&[("HOME", "/Users/me")]);
let fs = Fs::from_test_dir("my-test-dir/aws-config", "/Users/me/.aws/config");
assert_eq!(fs.read_to_end("/Users/me/.aws/config").await.unwrap(), b"test-config");

pub fn from_slice<'a>(files: &[(&'a str, &'a str)]) -> Self

Create a fake process environment from a slice of tuples.

Examples

use aws_types::os_shim_internal::Fs;
let mock_fs = Fs::from_slice(&[
    ("config", "[default]\nretry_mode = \"standard\""),
]);
assert_eq!(mock_fs.read_to_end("config").await.unwrap(), b"[default]\nretry_mode = \"standard\"");

pub async fn read_to_end(&self, path: impl AsRef<Path>) -> Result<Vec<u8>>

Read the entire contents of a file

Note: This function is currently async primarily for forward compatibility. Currently, this function does not use Tokio (or any other runtime) to perform IO, the IO is performed directly within the function.

pub async fn write( &self, path: impl AsRef<Path>, contents: impl AsRef<[u8]> ) -> Result<()>

Write a slice as the entire contents of a file.

This is equivalent to std::fs::write.

Trait Implementations

impl Clone for Fs

fn clone(&self) -> Fs

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Fs

fn default() -> Self

Returns the “default value” for a type.