mst incoming state logic fix

Signed-off-by: Mikhail Boldyrev <miboldyrev@gmail.com>

Author: MBoldyrev

irohad/multi_sig_transactions/impl/mst_processor_impl.cpp

@@ -86,10 +86,12 @@ namespace iroha {
   // -------------------| MstTransportNotification override |-------------------
 
   void FairMstProcessor::onNewState(const shared_model::crypto::PublicKey &from,
-                                    ConstRefState new_state) {
+                                    MstState new_state) {
     log_->info("Applying new state");
     auto current_time = time_provider_->getCurrentTime();
 
+    // no need to add already expired batches to local state
+    new_state.eraseExpired(current_time);
     auto state_update = storage_->apply(from, new_state);
 
     // updated batches
@@ -101,7 +103,8 @@ namespace iroha {
     completedBatchesNotify(*state_update.completed_state_);
 
     // expired batches
-    expiredBatchesNotify(storage_->getDiffState(from, current_time));
+    // not nesessary to do it right here, just use the occasion to clean storage
+    expiredBatchesNotify(storage_->extractExpiredTransactions(current_time));
   }
 
   // -----------------------------| private api |-----------------------------

irohad/multi_sig_transactions/mst_processor_impl.hpp

@@ -55,7 +55,7 @@ namespace iroha {
     // ------------------| MstTransportNotification override |------------------
 
     void onNewState(const shared_model::crypto::PublicKey &from,
-                    ConstRefState new_state) override;
+                    MstState new_state) override;
 
     // ----------------------------| end override |-----------------------------
 

irohad/network/mst_transport.hpp

@@ -23,9 +23,8 @@ namespace iroha {
        * @param from - key of the peer emitted the state
        * @param new_state - state propagated from peer
        */
-      virtual void onNewState(
-          const shared_model::crypto::PublicKey &from,
-          const MstState &new_state) = 0;
+      virtual void onNewState(const shared_model::crypto::PublicKey &from,
+                              MstState new_state) = 0;
 
       virtual ~MstTransportNotification() = default;
     };

test/framework/integration_framework/fake_peer/network/mst_message.hpp

@@ -12,9 +12,8 @@
 namespace integration_framework {
   namespace fake_peer {
     struct MstMessage final {
-      MstMessage(const shared_model::crypto::PublicKey &f,
-                 const iroha::MstState &s)
-          : from(f), state(s) {}
+      MstMessage(const shared_model::crypto::PublicKey &f, iroha::MstState s)
+          : from(f), state(std::move(s)) {}
       shared_model::crypto::PublicKey from;
       iroha::MstState state;
     };

test/framework/integration_framework/fake_peer/network/mst_network_notifier.cpp

@@ -10,10 +10,10 @@ namespace integration_framework {
 
     void MstNetworkNotifier::onNewState(
         const shared_model::crypto::PublicKey &from,
-        const iroha::MstState &new_state) {
+        iroha::MstState new_state) {
       std::lock_guard<std::mutex> guard(mst_subject_mutex_);
       mst_subject_.get_subscriber().on_next(
-          std::make_shared<MstMessage>(from, new_state));
+          std::make_shared<MstMessage>(from, std::move(new_state)));
     }
 
     rxcpp::observable<std::shared_ptr<MstMessage>>

test/framework/integration_framework/fake_peer/network/mst_network_notifier.hpp

@@ -21,7 +21,7 @@ namespace integration_framework {
         : public iroha::network::MstTransportNotification {
      public:
       void onNewState(const shared_model::crypto::PublicKey &from,
-                      const iroha::MstState &new_state) override;
+                      iroha::MstState new_state) override;
 
       rxcpp::observable<std::shared_ptr<MstMessage>> getObservable();
 

test/module/irohad/multi_sig_transactions/mst_mocks.hpp

@@ -33,7 +33,7 @@ namespace iroha {
    public:
     MOCK_METHOD2(onNewState,
                  void(const shared_model::crypto::PublicKey &from,
-                      const MstState &state));
+                      MstState state));
   };
 
   /**

test/module/irohad/multi_sig_transactions/mst_processor_test.cpp

@@ -319,3 +319,30 @@ TEST_F(MstProcessorTest, emptyStatePropagation) {
       another_peer};
   propagation_subject.get_subscriber().on_next(peers);
 }
+
+/**
+ * @given initialized mst processor with empty state
+ *
+ * @when received other peer's state containing an outdated batch
+ *
+ * @then check that transport was not invoked
+ * @and queues are not pushed to
+ * @and the batch does not get into our state
+ */
+TEST_F(MstProcessorTest, receivedOutdatedState) {
+  // ---------------------------------| then |----------------------------------
+  EXPECT_CALL(*transport, sendState(_, _)).Times(0);
+  auto observers = initObservers(mst_processor, 0, 0, 0);
+
+  // ---------------------------------| when |----------------------------------
+  shared_model::crypto::PublicKey another_peer_key("another_pubkey");
+  auto transported_state = MstState::empty(getTestLogger("MstState"),
+                                           std::make_shared<TestCompleter>());
+  const auto expired_batch = makeTestBatch(txBuilder(1, time_before, 3));
+  transported_state += addSignaturesFromKeyPairs(expired_batch, 0, makeKey());
+  mst_processor->onNewState(another_peer_key, transported_state);
+
+  // ---------------------------------| then |----------------------------------
+  EXPECT_FALSE(storage->batchInStorage(expired_batch));
+  check(observers);
+}