Add http/ipc jsonrpc testing to harness

Author: njgheorghita

CONTRIBUTING.md

@@ -22,8 +22,10 @@ through github via pull requests.
 * Mark unfinished pull requests with the "Work in Progress" label.
 * Before submitting a pr for review, you should run the following commands
   locally and make sure they are passing, otherwise CI will raise an error.
-  * `cargo fmt` and `cargo clippy` for linting checks
-  * `cargo test --workspace` to run all tests
+  * `cargo fmt -- --check` and `cargo clippy -- --deny warnings` for linting checks
+  * `RUSTFLAGS='-D warnings' cargo test --workspace` to run all tests
+  * Run the `ethportal-peertest` harness against a locally running node. Instructions
+	can be found in [README](ethportal-peertest/README.md).
 * Pull requests **should** always be reviewed by another member of the team
   prior to being merged.
     * Obvious exceptions include very small pull requests.

Cargo.lock

@@ -7,8 +7,10 @@ edition = "2018"
 
 [dependencies]
 clap = "2.33.3"
+hyper = { version = "0.14", features = ["full"] }
 log = "0.4.14"
 rocksdb = "0.16.0"
+serde_json = "1.0.59"
 structopt = "0.3"
 tokio = {version = "1.8.0", features = ["full"]}
 tracing = "0.1.26"

ethportal-peertest/Cargo.toml

@@ -5,6 +5,9 @@ Run a portal network node that you want to test and pass node's Enr as a target
 ```sh
 cd ethportal-peertest
 
-RUST_LOG=debug cargo run -p ethportal-peertest -- --target_node enr:-IS4QBDHCSMoYoC5UziAwKSyTmMPrhMaEpaE52L8DDAkipqvZQe9fgLy2wVuuEJwO9l1KsYrRoFGCsNjylbd0CDNw60BgmlkgnY0gmlwhMCoXUSJc2VjcDI1NmsxoQJPAZUFErHK1DZYRTLjk3SCNgye9sS-MxoQI-gLiUdwc4N1ZHCCIyk
+RUST_LOG=debug cargo run -p ethportal-peertest -- --target-node enr:-IS4QBDHCSMoYoC5UziAwKSyTmMPrhMaEpaE52L8DDAkipqvZQe9fgLy2wVuuEJwO9l1KsYrRoFGCsNjylbd0CDNw60BgmlkgnY0gmlwhMCoXUSJc2VjcDI1NmsxoQJPAZUFErHK1DZYRTLjk3SCNgye9sS-MxoQI-gLiUdwc4N1ZHCCIyk
+```
+
+## Transport selection
+Running the test harness will by default test all jsonrpc endpoints over IPC to the target node. To make sure these pass, please make sure that the target node is running with `--web3-transport ipc`. To test jsonrpc over http, use the `--target-transport http` cli argument for the harness, and make sure the target node is running with `--web3-transport http`. Ideally, both transport methods are tested before PRs.
 
-```

ethportal-peertest/README.md

@@ -15,24 +15,32 @@ pub struct PeertestConfig {
     #[structopt(
         default_value(DEFAULT_LISTEN_PORT),
         short = "p",
-        long = "listen_port",
+        long = "listen-port",
         help = "The UDP port to listen on."
     )]
     pub listen_port: u16,
 
     #[structopt(
         default_value(DEFAULT_WEB3_IPC_PATH),
-        long = "web3_ipc_path",
+        long = "web3-ipc-path",
         help = "path to json-rpc socket address over IPC"
     )]
     pub web3_ipc_path: String,
 
     #[structopt(
         short,
-        long = "target_node",
-        help = "Base64-encoded ENR's of the nodes under test"
+        long = "target-node",
+        help = "Base64-encoded ENR of the node under test"
     )]
     pub target_node: String,
+
+    #[structopt(
+        default_value = "ipc",
+        possible_values(&["http", "ipc"]),
+        long = "target-transport",
+        help = "Transport type of the node under test"
+    )]
+    pub target_transport: String,
 }
 
 impl PeertestConfig {

ethportal-peertest/src/cli.rs

@@ -0,0 +1,131 @@
+use std::io::prelude::*;
+use std::os::unix::net::UnixStream;
+use std::slice::Iter;
+
+use hyper::{self, Body, Client, Method, Request};
+use log::info;
+use serde_json::{self, Value};
+
+use trin_core::portalnet::U256;
+
+#[derive(Copy, Clone)]
+pub struct JsonRpcEndpoint {
+    pub method: &'static str,
+    pub id: &'static u8,
+}
+
+const ALL_ENDPOINTS: [JsonRpcEndpoint; 6] = [
+    JsonRpcEndpoint {
+        method: "web3_clientVersion",
+        id: &0,
+    },
+    JsonRpcEndpoint {
+        method: "discv5_nodeInfo",
+        id: &1,
+    },
+    JsonRpcEndpoint {
+        method: "discv5_routingTableInfo",
+        id: &2,
+    },
+    JsonRpcEndpoint {
+        method: "eth_blockNumber",
+        id: &3,
+    },
+    JsonRpcEndpoint {
+        method: "portalHistory_dataRadius",
+        id: &4,
+    },
+    JsonRpcEndpoint {
+        method: "portalState_dataRadius",
+        id: &5,
+    },
+];
+
+fn validate_endpoint_response(method: &str, result: &Value) {
+    match method {
+        "web3_clientVersion" => {
+            assert_eq!(result.as_str().unwrap(), "trin 0.0.1-alpha");
+        }
+        "discv5_nodeInfo" => {
+            let enr = result.get("enr").unwrap();
+            assert!(enr.is_string());
+            assert!(enr.as_str().unwrap().contains("enr:"));
+            assert!(result.get("nodeId").unwrap().is_string());
+        }
+        "discv5_routingTableInfo" => {
+            let local_key = result.get("localKey").unwrap();
+            assert!(local_key.is_string());
+            assert!(local_key.as_str().unwrap().contains("0x"));
+            assert!(result.get("buckets").unwrap().is_array());
+        }
+        "eth_blockNumber" => {
+            assert!(result.is_string());
+            assert!(result.as_str().unwrap().contains("0x"));
+        }
+        "portalHistory_dataRadius" => {
+            assert_eq!(result.as_str().unwrap(), U256::from(u64::MAX).to_string());
+        }
+        "portalState_dataRadius" => {
+            assert_eq!(result.as_str().unwrap(), U256::from(u64::MAX).to_string());
+        }
+        _ => panic!("Unsupported endpoint"),
+    };
+    info!("{:?} returned a valid response.", method);
+}
+
+impl JsonRpcEndpoint {
+    pub fn all_endpoints() -> Iter<'static, Self> {
+        ALL_ENDPOINTS.iter()
+    }
+
+    pub fn to_jsonrpc(self) -> Vec<u8> {
+        let data = format!(
+            r#"
+            {{
+                "jsonrpc":"2.0",
+                "id": {},
+                "method": "{}"
+            }}"#,
+            self.id, self.method
+        );
+        let v: Value = serde_json::from_str(&data).unwrap();
+        serde_json::to_vec(&v).unwrap()
+    }
+}
+
+pub async fn test_jsonrpc_endpoints_over_ipc() {
+    for endpoint in JsonRpcEndpoint::all_endpoints() {
+        info!("Testing over IPC: {:?}", endpoint.method);
+        let mut stream = UnixStream::connect("/tmp/trin-jsonrpc.ipc").unwrap();
+        stream.write_all(&endpoint.to_jsonrpc()).unwrap();
+        stream.flush().unwrap();
+        let deser = serde_json::Deserializer::from_reader(stream);
+        for obj in deser.into_iter::<Value>() {
+            let response_obj = obj.unwrap();
+            let result = response_obj.get("result").unwrap();
+            validate_endpoint_response(endpoint.method, result);
+        }
+    }
+}
+
+pub async fn test_jsonrpc_endpoints_over_http() {
+    let client = Client::new();
+    for endpoint in JsonRpcEndpoint::all_endpoints() {
+        info!("Testing over HTTP: {:?}", endpoint.method);
+        let json_string = format!(
+            r#"{{"jsonrpc":"2.0","id":0,"method":"{}","params":[]}}"#,
+            endpoint.method
+        );
+        let req = Request::builder()
+            .method(Method::POST)
+            .uri("http://127.0.0.1:8545")
+            .header("content-type", "application/json")
+            .body(Body::from(json_string))
+            .unwrap();
+        let resp = client.request(req).await.unwrap();
+        let body = hyper::body::to_bytes(resp.into_body()).await.unwrap();
+        let body_json: Value = serde_json::from_slice(&body).unwrap();
+        let result = body_json.get("result").unwrap();
+        validate_endpoint_response(endpoint.method, result);
+    }
+}