GH-580: test for data_directory_from_context with opt dir and implementation …

.gitignore

@@ -136,3 +136,6 @@ node.log
 lnk*.tmp
 /*/target/
 node_ui/static/binaries/
+
+# VSCode
+.vscode

masq/src/commands/setup_command.rs

@@ -6,16 +6,15 @@ use crate::terminal::terminal_interface::TerminalWrapper;
 use clap::{value_t, App, SubCommand};
 use masq_lib::constants::SETUP_ERROR;
 use masq_lib::implement_as_any;
-use masq_lib::messages::{
-    UiSetupBroadcast, UiSetupInner, UiSetupRequest, UiSetupRequestValue, UiSetupResponse,
-};
+use masq_lib::messages::{UiSetupBroadcast, UiSetupInner, UiSetupRequest, UiSetupRequestValue, UiSetupResponse, UiSetupResponseValue, UiSetupResponseValueStatus};
 use masq_lib::shared_schema::shared_app;
 use masq_lib::short_writeln;
 use masq_lib::utils::index_of_from;
 #[cfg(test)]
 use std::any::Any;
 use std::fmt::Debug;
 use std::io::Write;
+use std::iter::Iterator;
 
 pub const SETUP_COMMAND_TIMEOUT_MILLIS: u64 = 30000;
 
@@ -72,6 +71,7 @@ impl SetupCommand {
                 }
             })
             .collect::<Vec<UiSetupRequestValue>>();
+
         values.sort_by(|a, b| {
             a.name
                 .partial_cmp(&b.name)
@@ -107,6 +107,10 @@ impl SetupCommand {
                 .expect("String comparison failed")
         });
         short_writeln!(stdout, "{:29} {:64} {}", "NAME", "VALUE", "STATUS");
+        let chain_and_data_dir = |p: &UiSetupResponseValue| { (p.name.to_owned(), (p.value.clone(), p.status)) };
+        let chain = inner.values.iter().find(|&p| p.name.as_str() == "chain").map(chain_and_data_dir).expect("Chain name is missing in setup cluster!");
+        let data_directory = inner.values.iter().find(|&p| p.name.as_str() == "data-directory").map(chain_and_data_dir).expect("data-directory is missing in setup cluster!");
+
         inner.values.into_iter().for_each(|value| {
             short_writeln!(
                 stdout,
@@ -130,6 +134,14 @@ impl SetupCommand {
                 "NOTE: no changes were made to the setup because the Node is currently running.\n"
             );
         }
+        if chain.1.1 != UiSetupResponseValueStatus::Default
+            || data_directory.1.1 != UiSetupResponseValueStatus::Default
+        {
+            short_writeln!(
+                stdout,
+                "NOTE: your data directory was modified to match the chain parameter.\n"
+            );
+        }
     }
 }
 
@@ -338,4 +350,124 @@ ERRORS:
 ip                            No sir, I don't like it.\n\
 \n");
     }
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub struct SetupCommandData {
+        chain_str: Option<String>,
+        data_directory: Option<String>,
+        chain_name_expected: Option<&'static str>,
+        data_directory_expected: Option<&'static str>,
+        note_expected: bool,
+        status_chain: UiSetupResponseValueStatus,
+        status_data_dir: UiSetupResponseValueStatus
+    }
+
+    #[test]
+    fn setup_command_with_data_directory_shows_right_path() {
+        #[rustfmt::skip]
+        vec![
+            SetupCommandData {
+                chain_str: None,
+                data_directory: None,
+                chain_name_expected: Some("polygon-mainnet"),
+                data_directory_expected: Some("/home/cooga/.local/MASQ/polygon-mainnet"),
+                note_expected: false,
+                status_chain: UiSetupResponseValueStatus::Default,
+                status_data_dir: UiSetupResponseValueStatus::Default,
+            },
+            SetupCommandData {
+                chain_str: Some("polygon-mumbai".to_owned()),
+                data_directory: None,
+                chain_name_expected: Some("polygon-mumbai"),
+                data_directory_expected: Some("/home/cooga/.local/MASQ/polygon-mumbai"),
+                note_expected: true,
+                status_chain: UiSetupResponseValueStatus::Set,
+                status_data_dir: UiSetupResponseValueStatus::Default,
+            },
+            SetupCommandData {
+                chain_str: None,
+                data_directory: Some("booga".to_owned()),
+                chain_name_expected: Some("polygon-mainnet"),
+                data_directory_expected: Some("booga/polygon-mainnet"),
+                note_expected: true,
+                status_chain: UiSetupResponseValueStatus::Default,
+                status_data_dir: UiSetupResponseValueStatus::Set,
+            },
+            SetupCommandData {
+                chain_str: Some("polygon-mumbai".to_owned()),
+                data_directory: Some("booga/polygon-mumbai".to_owned()),
+                chain_name_expected: Some("polygon-mumbai"),
+                data_directory_expected: Some("booga/polygon-mumbai/polygon-mumbai"),
+                note_expected: true,
+                status_chain: UiSetupResponseValueStatus::Set,
+                status_data_dir: UiSetupResponseValueStatus::Set,
+            },
+        ].iter().for_each(|
+            data| {
+            let note_expected_real = match data.note_expected {
+                true => "\nNOTE: your data directory was modified to match the chain parameter.\n",
+                _ => ""
+            };
+            let status_data_dir_str = match data.status_data_dir {
+                Default => "Default",
+                Set => "Set",
+                Configured => "Configured",
+                UiSetupResponseValueStatus::Blank => "Blank",
+                UiSetupResponseValueStatus::Required => "Required"
+            };
+            let status_chain_str = match data.status_chain {
+                Default => "Default",
+                Set => "Set",
+                Configured => "Configured",
+                UiSetupResponseValueStatus::Blank => "Blank",
+                UiSetupResponseValueStatus::Required => "Required"
+            };
+            let expected = format!("\
+NAME                          VALUE                                                            STATUS\n\
+{:29} {:64} {}\n{:29} {:64} {}\n{}\n",
+                                   "chain",
+                                   data.chain_name_expected.unwrap(),
+                                   status_chain_str,
+                                   "data-directory",
+                                   data.data_directory_expected.unwrap(),
+                                   status_data_dir_str,
+                                   note_expected_real
+            );
+            let chain_real = match &data.chain_str { Some(chain) => chain, _ => "polygon-mainnet" };
+            let data_directory_real = match &data.data_directory {
+                Some(dir) => format!("{}/{}", dir, chain_real),
+                _ => format!("/home/cooga/.local/MASQ/{}", chain_real)
+            };
+            process_setup_command_for_given_attributes(
+                chain_real,
+                &data_directory_real,
+                &expected,
+                data.status_chain,
+                data.status_data_dir
+            );
+        });
+    }
+
+    fn process_setup_command_for_given_attributes(
+        chain: &str,
+        data_directory: &str,
+        expected: &str,
+        status_chain: UiSetupResponseValueStatus,
+        status_data_dir: UiSetupResponseValueStatus,
+    ) {
+        let message = UiSetupResponse {
+            running: false,
+            values: vec![
+                UiSetupResponseValue::new("chain", chain, status_chain),
+                UiSetupResponseValue::new("data-directory", data_directory, status_data_dir),
+            ],
+            errors: vec![],
+        };
+        let (stream_factory, handle) = TestStreamFactory::new();
+        let (mut stdout, _) = stream_factory.make();
+
+        SetupCommand::dump_setup(UiSetupInner::from(message), &mut stdout);
+
+        assert_eq!(handle.stdout_so_far(), expected);
+    }
 }

masq/tests/chain_specific_directory_test_integration.rs

@@ -0,0 +1,39 @@
+// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
+
+use crate::utils::{DaemonProcess, MasqProcess};
+use masq_lib::utils::find_free_port;
+use std::thread;
+use std::time::Duration;
+
+mod utils;
+
+#[test]
+fn ensure_data_directory_has_specific_chain_directory_within_integration() {
+    let port = find_free_port();
+    let daemon_handle = DaemonProcess::new().start(port.clone());
+    let masq_handle = MasqProcess::new().start_noninteractive(vec![
+        "--ui-port",
+        *&port.to_string().to_owned().as_str(),
+        "setup",
+    ]);
+    let (stdout, _stderr, _exit_code) = masq_handle.stop();
+    let mut masq_handle2 = MasqProcess::new().start_interactive(port, true);
+    let mut stdin_handle = masq_handle2.create_stdin_handle();
+
+    stdin_handle.type_command("setup --data-directory /home/booga/masqhome/polygon-mainnet");
+
+    thread::sleep(Duration::from_millis(1000));
+
+    stdin_handle.type_command("exit");
+
+    let (stdout2, _stderr2, _exit_code2) = masq_handle2.stop();
+    let expected = format!(
+        "{:29} {:64} {}",
+        "data-directory", "/home/booga/masqhome/polygon-mainnet", "Set"
+    );
+
+    assert!(!stdout.contains("MASQ/polygon-mainnet/MASQ/polygon-mainnet Default"), "Wrong directory: duplication of /MASQ/polygon-mainnet when Default");
+    assert!(stdout2.contains(&expected), "Wrong directory: missing chain specific directory when Set:\nstdout: {}\n", stdout2);
+
+    daemon_handle.kill();
+}

masq/tests/utils.rs

@@ -107,10 +107,12 @@ impl StdinHandle {
     }
     pub fn type_command(&mut self, command: &str) {
         match self.stdin.write_fmt(format_args!("{}\n", command)) {
-            Ok(_) => (),
+            Ok(_) => match self.stdin.flush() {
+                Ok(_) => (),
+                Err(e) => panic!("flush failed in type_command: {}", e),
+            },
             Err(e) => {
-                eprintln!("{}", e);
-                panic!("type_command failed: {}", e)
+                panic!("type_command write failed: {}", e)
             }
         }
     }

masq_lib/src/multi_config.rs

@@ -48,6 +48,7 @@ macro_rules! values_m {
     }};
 }
 
+#[derive(Debug)]
 pub struct MultiConfig<'a> {
     arg_matches: ArgMatches<'a>,
 }
@@ -1101,6 +1102,7 @@ pub mod tests {
         }
 
         let result = ConfigFileVcl::new(&file_path, true).err().unwrap();
+
         assert_contains(
             &result.to_string(),
             "doesn't make sense: parameter 'array' must have a scalar value, not an array value.",

masq_lib/src/utils.rs

@@ -1,11 +1,13 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
+use crate::blockchains::chains::Chain;
 use lazy_static::lazy_static;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::io;
 use std::io::ErrorKind;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener, UdpSocket};
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 
@@ -129,6 +131,18 @@ fn port_is_free_for_ip_addr(ip_addr: IpAddr, port: u16) -> bool {
     true
 }
 
+pub fn add_masq_and_chain_directories(chain: Chain, local_data_dir: &Path) -> PathBuf {
+    let masq_dir = PathBuf::from(local_data_dir).join("MASQ");
+    add_chain_specific_directory(chain, masq_dir.as_path())
+}
+
+pub fn add_chain_specific_directory(chain: Chain, local_data_dir: &Path) -> PathBuf {
+    match local_data_dir.ends_with(chain.rec().literal_identifier) {
+        true => PathBuf::from(local_data_dir),
+        false => PathBuf::from(local_data_dir).join(chain.rec().literal_identifier)
+    }
+}
+
 pub fn localhost() -> IpAddr {
     IpAddr::V4(Ipv4Addr::LOCALHOST)
 }

multinode_integration_tests/src/masq_node.rs

@@ -274,7 +274,7 @@ impl MASQNodeUtils {
                 "-t",
                 name,
                 "cat",
-                &format!("/node_root/home/{}", CURRENT_LOGFILE_NAME),
+                &format!("/node_root/home/MASQ/dev/{}", CURRENT_LOGFILE_NAME),
             ]),
         );
         command.stdout_and_stderr()

multinode_integration_tests/src/masq_real_node.rs

@@ -12,7 +12,7 @@ use log::Level;
 use masq_lib::blockchains::chains::Chain;
 use masq_lib::constants::{CURRENT_LOGFILE_NAME, DEFAULT_UI_PORT};
 use masq_lib::test_utils::utils::TEST_DEFAULT_MULTINODE_CHAIN;
-use masq_lib::utils::localhost;
+use masq_lib::utils::{add_masq_and_chain_directories, localhost};
 use masq_lib::utils::{DEFAULT_CONSUMING_DERIVATION_PATH, DEFAULT_EARNING_DERIVATION_PATH};
 use node_lib::blockchain::bip32::Bip32ECKeyProvider;
 use node_lib::sub_lib::accountant::{
@@ -29,6 +29,7 @@ use std::fmt::Display;
 use std::net::IpAddr;
 use std::net::Ipv4Addr;
 use std::net::SocketAddr;
+use std::path::Path;
 use std::rc::Rc;
 use std::str::FromStr;
 use std::string::ToString;
@@ -1151,6 +1152,8 @@ impl MASQRealNode {
 
     fn extract_node_reference(name: &str) -> Result<NodeReference, String> {
         let descriptor_regex = Self::descriptor_regex();
+        let chain_specific_directory =
+            add_masq_and_chain_directories(TEST_DEFAULT_MULTINODE_CHAIN, Path::new(DATA_DIRECTORY));
         let mut retries_left = 25;
         loop {
             if retries_left <= 0 {
@@ -1163,7 +1166,11 @@ impl MASQRealNode {
                 name,
                 vec![
                     "cat",
-                    &format!("{}/{}", DATA_DIRECTORY, CURRENT_LOGFILE_NAME),
+                    &format!(
+                        "{}/{}",
+                        &chain_specific_directory.to_string_lossy(),
+                        CURRENT_LOGFILE_NAME
+                    ),
                 ],
             ) {
                 Ok(output) => {
@@ -1182,7 +1189,10 @@ impl MASQRealNode {
                 Err(e) => {
                     println!(
                         "Failed to cat logfile for {} at {}/{}: {}",
-                        name, DATA_DIRECTORY, CURRENT_LOGFILE_NAME, e
+                        name,
+                        &chain_specific_directory.to_string_lossy(),
+                        CURRENT_LOGFILE_NAME,
+                        e
                     );
                 }
             };

multinode_integration_tests/src/utils.rs

@@ -70,10 +70,7 @@ pub fn wait_for_chunk(stream: &mut TcpStream, timeout: &Duration) -> Result<Vec<
 
 pub fn database_conn(node_name: &str) -> Box<dyn ConnectionWrapper> {
     let db_initializer = DbInitializerReal::default();
-    let path = std::path::PathBuf::from(MASQRealNode::node_home_dir(
-        &MASQNodeUtils::find_project_root(),
-        node_name,
-    ));
+    let path = std::path::PathBuf::from(node_chain_specific_data_directory(node_name));
     db_initializer
         .initialize(
             &path,
@@ -86,6 +83,13 @@ pub fn database_conn(node_name: &str) -> Box<dyn ConnectionWrapper> {
         .unwrap()
 }
 
+pub fn node_chain_specific_data_directory(node_name: &str) -> String {
+    format!(
+        "{}/MASQ/dev",
+        MASQRealNode::node_home_dir(&MASQNodeUtils::find_project_root(), node_name,)
+    )
+}
+
 pub fn config_dao(node_name: &str) -> Box<dyn ConfigDao> {
     Box::new(ConfigDaoReal::new(database_conn(node_name)))
 }