merge impl-v2: server

server/tests/test_util/mod.rs

@@ -0,0 +1,22 @@
+use rouille::Request;
+
+use librojo::web::Server;
+
+pub trait HttpTestUtil {
+    fn get_string(&self, url: &str) -> String;
+}
+
+impl HttpTestUtil for Server {
+    fn get_string(&self, url: &str) -> String {
+        let info_request = Request::fake_http("GET", url, vec![], vec![]);
+        let response = self.handle_request(&info_request);
+
+        assert_eq!(response.status_code, 200);
+
+        let (mut reader, _) = response.data.into_reader_and_size();
+        let mut body = String::new();
+        reader.read_to_string(&mut body).unwrap();
+
+        body
+    }
+}

server/tests/web.rs

@@ -0,0 +1,170 @@
+extern crate rouille;
+extern crate serde_json;
+extern crate serde;
+
+extern crate librojo;
+
+mod test_util;
+use test_util::*;
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use librojo::{
+    session::Session,
+    project::Project,
+    web::{Server, WebConfig, ServerInfoResponse, ReadResponse, ReadAllResponse},
+};
+
+#[test]
+fn empty() {
+    let project_path = {
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test-projects/empty");
+        path
+    };
+
+    let project = Project::load(&project_path).unwrap();
+    let mut session = Session::new(project.clone());
+    session.start();
+
+    let web_config = WebConfig::from_session(0, project.serve_port, &session);
+    let server = Server::new(web_config);
+
+    {
+        let body = server.get_string("/api/rojo");
+        let response = serde_json::from_str::<ServerInfoResponse>(&body).unwrap();
+
+        assert_eq!(response.server_id, "0");
+        assert_eq!(response.protocol_version, 2);
+        assert_eq!(response.partitions.len(), 0);
+    }
+
+    {
+        let body = server.get_string("/api/read_all");
+        let response = serde_json::from_str::<ReadAllResponse>(&body).unwrap();
+
+        assert_eq!(response.server_id, "0");
+        assert_eq!(response.message_cursor, -1);
+        assert_eq!(response.instances.len(), 0);
+    }
+
+    {
+        let body = server.get_string("/api/read/0");
+        let response = serde_json::from_str::<ReadResponse>(&body).unwrap();
+
+        assert_eq!(response.server_id, "0");
+        assert_eq!(response.message_cursor, -1);
+        assert_eq!(response.instances.len(), 0);
+    }
+}
+
+#[test]
+fn one_partition() {
+    let project_path = {
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test-projects/one-partition");
+        path
+    };
+
+    let project = Project::load(&project_path).unwrap();
+    let mut session = Session::new(project.clone());
+    session.start();
+
+    let web_config = WebConfig::from_session(0, project.serve_port, &session);
+    let server = Server::new(web_config);
+
+    {
+        let body = server.get_string("/api/rojo");
+        let response = serde_json::from_str::<ServerInfoResponse>(&body).unwrap();
+
+        let mut partitions = HashMap::new();
+        partitions.insert("lib".to_string(), vec!["ReplicatedStorage".to_string(), "OnePartition".to_string()]);
+
+        assert_eq!(response.server_id, "0");
+        assert_eq!(response.protocol_version, 2);
+        assert_eq!(response.partitions, partitions);
+    }
+
+    {
+        let body = server.get_string("/api/read_all");
+        let response = serde_json::from_str::<ReadAllResponse>(&body).unwrap();
+
+        let partition_id = *response.partition_instances.get("lib").unwrap();
+
+        assert_eq!(response.server_id, "0");
+        assert_eq!(response.message_cursor, -1);
+        assert_eq!(response.instances.len(), 4); // root and three children
+
+        let mut found_root = false;
+        let mut found_module = false;
+        let mut found_client = false;
+        let mut found_server = false;
+
+        for (id, instance) in response.instances.iter() {
+            match instance.class_name.as_str() {
+                // TOOD: Should partition roots (and other directories) be some
+                // magical object instead of Folder?
+                "Folder" => {
+                    assert!(!found_root);
+                    found_root = true;
+
+                    assert_eq!(*id, partition_id);
+
+                    // TODO: Should this actually equal the last part of the
+                    // partition's target?
+                    assert_eq!(instance.name, "OnePartition");
+
+                    assert_eq!(instance.properties.len(), 0);
+                    assert_eq!(instance.parent, None);
+                    assert_eq!(instance.children.len(), 3);
+                },
+                "ModuleScript" => {
+                    assert!(!found_module);
+                    found_module = true;
+
+                    let mut properties = HashMap::new();
+                    properties.insert("Source".to_string(), "-- a.lua".to_string());
+
+                    assert_eq!(instance.name, "a");
+                    assert_eq!(instance.properties, properties);
+                    assert_eq!(instance.parent, Some(partition_id));
+                    assert_eq!(instance.children.len(), 0);
+                },
+                "LocalScript" => {
+                    assert!(!found_client);
+                    found_client = true;
+
+                    let mut properties = HashMap::new();
+                    properties.insert("Source".to_string(), "-- b.client.lua".to_string());
+
+                    assert_eq!(instance.name, "b");
+                    assert_eq!(instance.properties, properties);
+                    assert_eq!(instance.parent, Some(partition_id));
+                    assert_eq!(instance.children.len(), 0);
+                },
+                "Script" => {
+                    assert!(!found_server);
+                    found_server = true;
+
+                    let mut properties = HashMap::new();
+                    properties.insert("Source".to_string(), "-- a.server.lua".to_string());
+
+                    assert_eq!(instance.name, "a");
+                    assert_eq!(instance.properties, properties);
+                    assert_eq!(instance.parent, Some(partition_id));
+                    assert_eq!(instance.children.len(), 0);
+                },
+                _ => panic!("Unexpected instance!"),
+            }
+        }
+
+        assert!(found_root);
+        assert!(found_module);
+        assert!(found_client);
+        assert!(found_server);
+    }
+
+    // TODO: Test /read
+    // TODO: Test /subscribe
+}