light-client: integration test

.github/workflows/rust.yml

@@ -84,6 +84,10 @@ jobs:
         with:
           command: test
           args: -p tendermint --test integration --no-fail-fast -- --ignored
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: -p tendermint-light-client --test integration --no-fail-fast -- --ignored
 
   test-integration-latest:
     runs-on: ubuntu-latest

CHANGES.md

@@ -5,10 +5,12 @@ Light Client:
 - Expose latest_trusted from Supervisor Handle ([#394])
 - Turn `Handle` into a trait for ease of integration and testability ([#401])
 - Improve `Supervisor` ergonomics according to [ADR-007] ([#403])
+- Add integration test ([#431])
 
 [#394]: https://github.com/informalsystems/tendermint-rs/pull/394
 [#401]: https://github.com/informalsystems/tendermint-rs/pull/401
 [#403]: https://github.com/informalsystems/tendermint-rs/pull/403
+[#431]: https://github.com/informalsystems/tendermint-rs/pull/431
 [ADR-007]: https://github.com/informalsystems/tendermint-rs/blob/master/docs/architecture/adr-007-light-client-supervisor-ergonomics.md
 
 ## [0.14.1] (2020-06-23)

light-client/src/contracts.rs

@@ -12,6 +12,7 @@ pub fn trusted_store_contains_block_at_target_height(
     target_height: Height,
 ) -> bool {
     light_store.get(target_height, Status::Verified).is_some()
+        || light_store.get(target_height, Status::Trusted).is_some()
 }
 
 pub fn is_within_trust_period(

light-client/src/evidence.rs

@@ -1,11 +1,13 @@
 use crate::{components::io::IoError, types::PeerId};
 
-use tendermint::{abci::transaction::Hash, evidence::Evidence};
+use tendermint::abci::transaction::Hash;
 use tendermint_rpc as rpc;
 
 use contracts::{contract_trait, pre};
 use std::collections::HashMap;
 
+pub use tendermint::evidence::Evidence;
+
 /// Interface for reporting evidence to full nodes, typically via the RPC client.
 #[contract_trait]
 pub trait EvidenceReporter: Send {

light-client/tests/integration.rs

@@ -0,0 +1,121 @@
+//! Light Client integration tests.
+//!
+//! These are all ignored by default, since they test against running
+//! `tendermint node --proxy_app=kvstore`. They can be run using:
+//!
+//! ```
+//! cargo test -- --ignored
+//! ```
+
+use tendermint_light_client::{
+    components::{
+        clock::SystemClock,
+        io::{AtHeight, Io, IoError, ProdIo},
+        scheduler,
+        verifier::ProdVerifier,
+    },
+    evidence::{Evidence, EvidenceReporter},
+    fork_detector::ProdForkDetector,
+    light_client::{self, LightClient},
+    peer_list::PeerList,
+    state::State,
+    store::{memory::MemoryStore, LightStore},
+    supervisor::{Handle, Instance, Supervisor},
+    types::{PeerId, Status, Time, TrustThreshold},
+};
+
+use tendermint::abci::transaction::Hash as TransactionHash;
+
+use std::collections::HashMap;
+use std::time::Duration;
+
+fn make_instance(peer_id: PeerId, options: light_client::Options, io: ProdIo) -> Instance {
+    let trusted_state = io
+        .fetch_light_block(peer_id, AtHeight::Highest)
+        .expect("could not request latest light block");
+
+    let mut light_store = MemoryStore::new();
+    light_store.insert(trusted_state, Status::Trusted);
+
+    let state = State {
+        light_store: Box::new(light_store),
+        verification_trace: HashMap::new(),
+    };
+
+    let verifier = ProdVerifier::default();
+    let clock = SystemClock;
+    let scheduler = scheduler::basic_bisecting_schedule;
+
+    let light_client = LightClient::new(peer_id, options, clock, scheduler, verifier, io);
+
+    Instance::new(light_client, state)
+}
+
+struct TestEvidenceReporter;
+
+#[contracts::contract_trait]
+impl EvidenceReporter for TestEvidenceReporter {
+    fn report(&self, evidence: Evidence, peer: PeerId) -> Result<TransactionHash, IoError> {
+        panic!(
+            "unexpected fork detected for peer {} with evidence: {:?}",
+            peer, evidence
+        );
+    }
+}
+
+#[test]
+#[ignore]
+fn sync() {
+    let primary: PeerId = "BADFADAD0BEFEEDC0C0ADEADBEEFC0FFEEFACADE".parse().unwrap();
+    let witness: PeerId = "CEFEEDBADFADAD0C0CEEFACADE0ADEADBEEFC0FF".parse().unwrap();
+
+    let node_address: tendermint::net::Address = "tcp://127.0.0.1:26657".parse().unwrap();
+
+    let mut peer_map = HashMap::new();
+    peer_map.insert(primary, node_address.clone());
+    peer_map.insert(witness, node_address);
+
+    let io = ProdIo::new(peer_map, Some(Duration::from_secs(2)));
+
+    let options = light_client::Options {
+        trust_threshold: TrustThreshold {
+            numerator: 1,
+            denominator: 3,
+        },
+        trusting_period: Duration::from_secs(36000),
+        clock_drift: Duration::from_secs(1),
+        now: Time::now(),
+    };
+
+    let primary_instance = make_instance(primary, options, io.clone());
+    let witness_instance = make_instance(witness, options, io);
+
+    let peer_list = PeerList::builder()
+        .primary(primary, primary_instance)
+        .witness(witness, witness_instance)
+        .build();
+
+    let mut supervisor =
+        Supervisor::new(peer_list, ProdForkDetector::default(), TestEvidenceReporter);
+
+    let handle = supervisor.handle();
+    std::thread::spawn(|| supervisor.run());
+
+    let max_iterations: usize = 20;
+
+    for i in 1..=max_iterations {
+        println!("[info ] - iteration {}/{}", i, max_iterations);
+
+        match handle.verify_to_highest() {
+            Ok(light_block) => {
+                println!("[info ] synced to block {}", light_block.height());
+            }
+            Err(err) => {
+                println!("[error] sync failed: {}", err);
+                panic!("failed to sync to highest: {}", err);
+            }
+        }
+
+        std::thread::sleep(Duration::from_millis(800));
+    }
+}