More fuzzing fixes

test/fuzzing/CMakeLists.txt

@@ -39,6 +39,7 @@ add_executable(send_batches_fuzz send_batches_fuzz.cpp)
 target_link_libraries(send_batches_fuzz
   gtest::gtest
   gmock::gmock
+  ametsuchi
   on_demand_ordering_service
   on_demand_ordering_service_transport_grpc
   protobuf-mutator
@@ -86,5 +87,6 @@ target_link_libraries(mst_fuzz
   gtest::gtest
   gmock::gmock
   mst_transport
+  ametsuchi
   protobuf-mutator
   )

test/fuzzing/mst_fuzz.cpp

@@ -8,11 +8,14 @@
 #include <gtest/gtest.h>
 #include <libfuzzer/libfuzzer_macro.h>
 
+#include "ametsuchi/impl/tx_presence_cache_impl.hpp"
 #include "backend/protobuf/proto_transport_factory.hpp"
 #include "interfaces/iroha_internal/transaction_batch_factory_impl.hpp"
 #include "interfaces/iroha_internal/transaction_batch_parser_impl.hpp"
+#include "module/irohad/ametsuchi/ametsuchi_mocks.hpp"
 #include "module/irohad/multi_sig_transactions/mst_test_helpers.hpp"
 #include "multi_sig_transactions/transport/mst_transport_grpc.hpp"
+#include "validators/protobuf/proto_transaction_validator.hpp"
 
 using namespace testing;
 using namespace iroha::network;
@@ -22,27 +25,40 @@ namespace fuzzing {
     std::shared_ptr<MstTransportGrpc> mst_transport_grpc_;
 
     MstFixture() {
+      spdlog::set_level(spdlog::level::err);
+
       auto async_call_ = std::make_shared<
           iroha::network::AsyncGrpcClient<google::protobuf::Empty>>();
+      // TODO luckychess 25.12.2018 Component initialisation reuse
+      // IR-1886, IR-142
       std::unique_ptr<shared_model::validation::AbstractValidator<
           shared_model::interface::Transaction>>
-          // TODO luckychess 20.11.2018 Reuse validator from application.cpp IR-1886
-          tx_validator =
-              std::make_unique<shared_model::validation::
-                                   DefaultOptionalSignedTransactionValidator>();
+          interface_validator = std::make_unique<
+              shared_model::validation::DefaultUnsignedTransactionValidator>();
+      std::unique_ptr<shared_model::validation::AbstractValidator<
+          iroha::protocol::Transaction>>
+          tx_validator = std::make_unique<
+              shared_model::validation::ProtoTransactionValidator>();
+
       auto tx_factory =
           std::make_shared<shared_model::proto::ProtoTransportFactory<
               shared_model::interface::Transaction,
-              shared_model::proto::Transaction>>(std::move(tx_validator));
+              shared_model::proto::Transaction>>(std::move(interface_validator),
+                                                 std::move(tx_validator));
       auto parser = std::make_shared<
           shared_model::interface::TransactionBatchParserImpl>();
       auto batch_factory = std::make_shared<
           shared_model::interface::TransactionBatchFactoryImpl>();
+      auto storage =
+          std::make_shared<NiceMock<iroha::ametsuchi::MockStorage>>();
+      auto cache =
+          std::make_shared<iroha::ametsuchi::TxPresenceCacheImpl>(storage);
       mst_transport_grpc_ = std::make_shared<MstTransportGrpc>(
           async_call_,
           std::move(tx_factory),
           std::move(parser),
           std::move(batch_factory),
+          std::move(cache),
           shared_model::crypto::DefaultCryptoAlgorithmType::generateKeypair()
               .publicKey());
     }

test/fuzzing/ordering_service_fixture.hpp

@@ -36,8 +36,6 @@ namespace fuzzing {
         batch_parser_;
     std::shared_ptr<NiceMock<MockTransactionBatchFactory>>
         transaction_batch_factory_;
-    shared_model::validation::AbstractValidator<
-        shared_model::interface::Transaction> *transaction_validator_;
 
     OrderingServiceFixture() {
       // fuzzing target is intended to run many times (~millions) so any
@@ -46,19 +44,19 @@ namespace fuzzing {
 
       std::unique_ptr<shared_model::validation::AbstractValidator<
           shared_model::interface::Transaction>>
-          transaction_validator =
-              std::make_unique<shared_model::validation::
-                                   DefaultOptionalSignedTransactionValidator>();
-      transaction_validator_ = transaction_validator.get();
+          interface_transaction_validator =
+              std::make_unique<NiceMock<shared_model::validation::MockValidator<
+                  shared_model::interface::Transaction>>>();
       std::unique_ptr<shared_model::validation::AbstractValidator<
           iroha::protocol::Transaction>>
-          proto_transaction_validator = std::make_unique<
-              shared_model::validation::ProtoTransactionValidator>();
+          proto_transaction_validator =
+              std::make_unique<NiceMock<shared_model::validation::MockValidator<
+                  iroha::protocol::Transaction>>>();
       transaction_factory_ =
           std::make_shared<shared_model::proto::ProtoTransportFactory<
               shared_model::interface::Transaction,
               shared_model::proto::Transaction>>(
-              std::move(transaction_validator),
+              std::move(interface_transaction_validator),
               std::move(proto_transaction_validator));
 
       batch_parser_ = std::make_shared<

test/fuzzing/send_batches_fuzz.cpp

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include "ametsuchi/impl/tx_presence_cache_impl.hpp"
+#include "module/irohad/ametsuchi/ametsuchi_mocks.hpp"
 #include "ordering_service_fixture.hpp"
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, std::size_t size) {
@@ -16,8 +18,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, std::size_t size) {
   std::shared_ptr<OnDemandOsServerGrpc> server_;
 
   auto proposal_factory = std::make_unique<MockUnsafeProposalFactory>();
+  auto storage = std::make_shared<NiceMock<iroha::ametsuchi::MockStorage>>();
+  auto cache = std::make_shared<iroha::ametsuchi::TxPresenceCacheImpl>(storage);
   ordering_service_ = std::make_shared<OnDemandOrderingServiceImpl>(
-      data[0], std::move(proposal_factory));
+      data[0], std::move(proposal_factory), std::move(cache));
   server_ = std::make_shared<OnDemandOsServerGrpc>(
       ordering_service_,
       fixture.transaction_factory_,