graph: Add deduplicate triggers test

Author: evaporei

chain/ethereum/src/tests.rs

@@ -112,3 +112,99 @@ fn test_trigger_ordering() {
         vec![log1, log2, call1, log3, call2, call4, call3, block2, block1]
     );
 }
+
+#[test]
+fn test_trigger_dedup() {
+    let block1 = EthereumTrigger::Block(
+        BlockPtr::from((H256::random(), 1u64)),
+        EthereumBlockTriggerType::Every,
+    );
+
+    let block2 = EthereumTrigger::Block(
+        BlockPtr::from((H256::random(), 0u64)),
+        EthereumBlockTriggerType::WithCallTo(Address::random()),
+    );
+
+    // duplicate block2
+    let block3 = block2.clone();
+
+    let mut call1 = EthereumCall::default();
+    call1.transaction_index = 1;
+    let call1 = EthereumTrigger::Call(Arc::new(call1));
+
+    let mut call2 = EthereumCall::default();
+    call2.transaction_index = 2;
+    let call2 = EthereumTrigger::Call(Arc::new(call2));
+
+    let mut call3 = EthereumCall::default();
+    call3.transaction_index = 3;
+    let call3 = EthereumTrigger::Call(Arc::new(call3));
+
+    // duplicate call2
+    let mut call4 = EthereumCall::default();
+    call4.transaction_index = 2;
+    let call4 = EthereumTrigger::Call(Arc::new(call4));
+
+    fn create_log(tx_index: u64, log_index: u64) -> Arc<Log> {
+        Arc::new(Log {
+            address: H160::default(),
+            topics: vec![],
+            data: Bytes::default(),
+            block_hash: Some(H256::zero()),
+            block_number: Some(U64::zero()),
+            transaction_hash: Some(H256::zero()),
+            transaction_index: Some(tx_index.into()),
+            log_index: Some(log_index.into()),
+            transaction_log_index: Some(log_index.into()),
+            log_type: Some("".into()),
+            removed: Some(false),
+        })
+    }
+
+    let log1 = EthereumTrigger::Log(create_log(1, 0), None);
+    let log2 = EthereumTrigger::Log(create_log(1, 1), None);
+    let log3 = EthereumTrigger::Log(create_log(2, 5), None);
+    // duplicate logs 2 and 3
+    let log4 = log2.clone();
+    let log5 = log3.clone();
+
+    let triggers = vec![
+        // Call triggers
+        call3.clone(),
+        call1.clone(),
+        call2.clone(),
+        call4.clone(),
+        // Block triggers
+        block3.clone(),
+        block2.clone(),
+        block1.clone(),
+        // Event triggers
+        log5.clone(),
+        log4.clone(),
+        log3.clone(),
+        log2.clone(),
+        log1.clone(),
+    ];
+
+    let logger = Logger::root(slog::Discard, o!());
+
+    let mut b: LightEthereumBlock = Default::default();
+
+    // This is necessary because inside of BlockWithTriggers::new
+    // there's a log for both fields. So just using Default above
+    // gives None on them.
+    b.number = Some(Default::default());
+    b.hash = Some(Default::default());
+
+    // Test that `BlockWithTriggers` sorts the triggers.
+    let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
+        BlockFinality::Final(Arc::new(b)),
+        triggers,
+        &logger,
+    );
+
+    assert_eq!(
+        block_with_triggers.trigger_data,
+        vec![log1, log2, call1, log3, call2, call3, block2, block1]
+    );
+}