Add tests for all but the content syntax parser module

src/syntax/command.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use crate::prelude::*;
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct Arguments {
     pub hostname: String,
     pub port: u16,
@@ -57,3 +57,58 @@ fn parse(defaults: &Arguments, args: &[String]) -> Arguments {
     }
     out_args
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn address() {
+        let args = Arguments {
+            hostname: String::from("localhost"),
+            port: 3007,
+            graph_path: PathBuf::new(),
+        };
+
+        assert_eq!(args.make_address(), "localhost:3007");
+    }
+
+    #[test]
+    fn hostname() {
+        let defaults = Arguments::new();
+
+        let payload = String::from("olUCu7vWcUAsumv2xpj2Z55EDheWLTEu");
+        let args =
+            parse(&defaults, &[String::from("-h"), String::from(&payload)]);
+        assert_eq!(args.hostname, payload);
+    }
+
+    #[test]
+    fn port() {
+        let defaults = Arguments::new();
+
+        let payload = 3901;
+        let args = parse(&defaults, &[String::from("-p"), payload.to_string()]);
+        assert_eq!(args.port, payload);
+    }
+
+    #[test]
+    fn graph_path() {
+        let defaults = Arguments::new();
+
+        let payload = PathBuf::from("/tmp/");
+        let args = parse(
+            &defaults,
+            &[String::from("-g"), payload.to_str().unwrap().to_string()],
+        );
+        assert_eq!(args.graph_path, payload);
+    }
+
+    #[test]
+    fn empty() {
+        let defaults = Arguments::new();
+
+        let args = parse(&defaults, &[]);
+        assert_eq!(defaults, args);
+    }
+}

src/syntax/serial.rs

@@ -128,11 +128,97 @@ pub fn deserialize_graph(in_format: &Format, serial: &str) -> Graph {
     match *in_format {
         Format::TOML => match toml::from_str(serial) {
             Ok(g) => g,
-            Err(error) => Graph::new(Some(error.to_string())),
+            Err(error) => Graph::new(Some(&error.to_string())),
         },
         Format::JSON => match serde_json::from_str(serial) {
             Ok(g) => g,
-            Err(error) => Graph::new(Some(error.to_string())),
+            Err(error) => Graph::new(Some(&error.to_string())),
         },
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn good_json() {
+        let json = r#"
+        {
+            "nodes": {
+                "JSON": {
+                    "text": "",
+                    "title": "JSON",
+                    "links": [],
+                    "id": "JSON",
+                    "hidden": false,
+                    "connections": []
+                }
+            },
+            "root_node": "JSON"
+        }
+        "#;
+
+        let graph = deserialize_graph(&Format::JSON, json);
+        assert!(graph.meta.messages.is_empty());
+    }
+
+    #[test]
+    fn bad_json() {
+        let graph = deserialize_graph(&Format::JSON, ":::");
+        let message = graph.meta.messages.first().unwrap();
+        assert!(message.contains("expected value at line 1 column 1"));
+    }
+
+    #[test]
+    fn detached_node() {
+        let node = Node {
+            id: String::from("SomeNode"),
+            text: String::new(),
+            title: String::new(),
+            links: vec![String::new()],
+            hidden: false,
+            connections: Some(vec![Edge {
+                anchor: String::from("SomeAnchor"),
+                from: String::new(),
+                to: String::new(),
+                detached: false,
+            }]),
+        };
+
+        let mut map: HashMap<String, Node> = HashMap::new();
+        map.insert(String::from("SomeNode"), node);
+
+        let modulated_map = modulate_nodes(&map);
+        let modulated_node = modulated_map.get("SomeNode").unwrap().clone();
+        let modulated_connections = modulated_node.connections.unwrap();
+        let modulated_connection = modulated_connections.first().unwrap();
+        assert!(modulated_connection.anchor == "SomeAnchor");
+        assert!(modulated_connection.detached);
+    }
+}
+
+#[cfg(test)]
+mod serial_tests {
+    use super::*;
+
+    #[test]
+    fn bad_graph_path() {
+        println!("T");
+        let original_working_directory = std::env::current_dir().unwrap();
+
+        assert!(
+            std::env::set_current_dir(std::path::Path::new(
+                "tests/mocks/no_graph"
+            ))
+            .is_ok()
+        );
+
+        let graph = populate_graph();
+        let message = graph.meta.messages.first().unwrap();
+        assert!(message.contains("TOML parse error"));
+        assert!(message.contains("No such file or directory"));
+
+        assert!(std::env::set_current_dir(original_working_directory).is_ok());
+    }
+}