flowr 1.0.0

Runners for compiled 'flow' programs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::sync::{Arc, Mutex};

use flowcore::errors::Result;
use flowcore::{Implementation, RunAgain, DONT_RUN_AGAIN, RUN_AGAIN};
use serde_json::{json, Value};

use crate::gui::client_message::ClientMessage;
use crate::gui::coordinator_connection::CoordinatorConnection;
use crate::gui::coordinator_message::CoordinatorMessage;

/// `Implementation` struct for the `file_read` function
pub struct FileRead {
    /// It holds a reference to the runtime client in order to get file contents
    pub server_connection: Arc<Mutex<CoordinatorConnection>>,
}

impl Implementation for FileRead {
    fn run(&self, inputs: &[Value]) -> Result<(Option<Value>, RunAgain)> {
        let path = inputs.first().ok_or("Could not get filename")?;

        let mut server = self
            .server_connection
            .lock()
            .map_err(|_| "Could not lock server")?;

        let response = server.send_and_receive_response::<CoordinatorMessage, ClientMessage>(
            CoordinatorMessage::Read(path.as_str().unwrap_or("").to_string()),
        );

        match response {
            Ok(ClientMessage::FileContents(_path, bytes)) => {
                let mut output_map = serde_json::Map::new();
                output_map.insert("bytes".into(), json!(bytes));
                let string =
                    String::from_utf8(bytes).map_err(|_| "Could not create Utf8 String")?;
                output_map.insert("string".into(), json!(string));
                Ok((Some(Value::Object(output_map)), RUN_AGAIN))
            }
            _ => Ok((None, DONT_RUN_AGAIN)),
        }
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod test {
    use flowcore::{Implementation, RUN_AGAIN};
    use serde_json::{json, Value};
    use serial_test::serial;

    use crate::gui::client_message::ClientMessage::FileContents;
    use crate::gui::coordinator_message::CoordinatorMessage;
    use crate::gui::test_helper::test::wait_for_then_send;

    use super::FileRead;

    #[test]
    #[serial]
    fn read_file() {
        let file_path = "test_read";
        let file_contents: Vec<u8> = "test text".as_bytes().to_vec();
        let file_string =
            String::from_utf8(file_contents.clone()).expect("Could not create Utf8 String");

        let inputs = [json!(file_path)];
        let file_read_message = CoordinatorMessage::Read(file_path.to_string());

        let server_connection = wait_for_then_send(
            file_read_message,
            FileContents(file_path.to_string(), file_contents),
        );

        let reader = &FileRead { server_connection } as &dyn Implementation;

        let (value, run_again) = reader.run(&inputs).expect("_file_write() failed");

        assert_eq!(run_again, RUN_AGAIN);
        match value {
            Some(Value::Object(map)) => {
                assert_eq!(
                    map.get("string")
                        .expect("Could not get file contents as string"),
                    &json!(file_string)
                );
            }
            _ => panic!("Did not get back FileContents"),
        }
    }
}