Spawn test node process for integration tests (#252)

* Move tests to module in own file

* Add test-node-proc crate

* Move test node to main lib, fix compilation errors

* Fmt

* Attempted port scanning

* Use global static port to allocate open ports

* Register missing type sizes

* Fix port scanning and balances test

* Don't wait for blocks on insert_jey test

* Fmt

* Remove unused dependencies

* Download v3.0.0 rust binary

* Move substrate bin to home dir

* Add test instructions to README

* Figure out the $PATH

* Remove path echo

* Add check for missing substrate binary on the PATH

* @niklasad1 review: don't include client feature for tests

src/tests/mod.rs

@@ -0,0 +1,176 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of substrate-subxt.
+//
+// subxt is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// subxt is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.
+
+mod node_proc;
+
+use super::*;
+use node_proc::TestNodeProcess;
+use sp_core::storage::{
+    well_known_keys,
+    StorageKey,
+};
+use sp_keyring::AccountKeyring;
+
+/// substrate node should be installed on the $PATH
+const SUBSTRATE_NODE_PATH: &str = "substrate";
+
+pub(crate) type TestRuntime = crate::DefaultNodeRuntime;
+
+pub(crate) async fn test_node_process_with(
+    key: AccountKeyring,
+) -> TestNodeProcess<TestRuntime> {
+    if which::which(SUBSTRATE_NODE_PATH).is_err() {
+        panic!("A substrate binary should be installed on your path for integration tests. See https://github.com/paritytech/substrate-subxt/tree/master#integration-testing")
+    }
+
+    let proc = TestNodeProcess::<TestRuntime>::build(SUBSTRATE_NODE_PATH)
+        .with_authority(key)
+        .scan_for_open_ports()
+        .spawn::<TestRuntime>()
+        .await;
+    proc.unwrap()
+}
+
+pub(crate) async fn test_node_process() -> TestNodeProcess<TestRuntime> {
+    test_node_process_with(AccountKeyring::Alice).await
+}
+
+#[async_std::test]
+async fn test_insert_key() {
+    let test_node_process = test_node_process_with(AccountKeyring::Bob).await;
+    let client = test_node_process.client();
+    let public = AccountKeyring::Alice.public().as_array_ref().to_vec();
+    client
+        .insert_key(
+            "aura".to_string(),
+            "//Alice".to_string(),
+            public.clone().into(),
+        )
+        .await
+        .unwrap();
+    assert!(client
+        .has_key(public.clone().into(), "aura".to_string())
+        .await
+        .unwrap());
+}
+
+#[async_std::test]
+async fn test_tx_transfer_balance() {
+    let mut signer = PairSigner::new(AccountKeyring::Alice.pair());
+    let dest = AccountKeyring::Bob.to_account_id().into();
+
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let nonce = client
+        .account(&AccountKeyring::Alice.to_account_id(), None)
+        .await
+        .unwrap()
+        .nonce;
+    signer.set_nonce(nonce);
+    client
+        .submit(
+            balances::TransferCall {
+                to: &dest,
+                amount: 10_000,
+            },
+            &signer,
+        )
+        .await
+        .unwrap();
+
+    // check that nonce is handled correctly
+    signer.increment_nonce();
+    client
+        .submit(
+            balances::TransferCall {
+                to: &dest,
+                amount: 10_000,
+            },
+            &signer,
+        )
+        .await
+        .unwrap();
+}
+
+#[async_std::test]
+async fn test_getting_hash() {
+    let node_process = test_node_process().await;
+    node_process.client().block_hash(None).await.unwrap();
+}
+
+#[async_std::test]
+async fn test_getting_block() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let block_hash = client.block_hash(None).await.unwrap();
+    client.block(block_hash).await.unwrap();
+}
+
+#[async_std::test]
+async fn test_getting_read_proof() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let block_hash = client.block_hash(None).await.unwrap();
+    client
+        .read_proof(
+            vec![
+                StorageKey(well_known_keys::HEAP_PAGES.to_vec()),
+                StorageKey(well_known_keys::EXTRINSIC_INDEX.to_vec()),
+            ],
+            block_hash,
+        )
+        .await
+        .unwrap();
+}
+
+#[async_std::test]
+async fn test_chain_subscribe_blocks() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let mut blocks = client.subscribe_blocks().await.unwrap();
+    blocks.next().await;
+}
+
+#[async_std::test]
+async fn test_chain_subscribe_finalized_blocks() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let mut blocks = client.subscribe_finalized_blocks().await.unwrap();
+    blocks.next().await;
+}
+
+#[async_std::test]
+async fn test_fetch_keys() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let keys = client
+        .fetch_keys::<system::AccountStore<_>>(4, None, None)
+        .await
+        .unwrap();
+    assert_eq!(keys.len(), 4)
+}
+
+#[async_std::test]
+async fn test_iter() {
+    let node_process = test_node_process().await;
+    let client = node_process.client();
+    let mut iter = client.iter::<system::AccountStore<_>>(None).await.unwrap();
+    let mut i = 0;
+    while let Some(_) = iter.next().await.unwrap() {
+        i += 1;
+    }
+    assert_eq!(i, 13);
+}