simplify

Author: martinzink

extension-framework/cpp-extension-lib/mocklib/include/MockProcessSession.h

@@ -24,28 +24,29 @@
 #include "range/v3/range/conversion.hpp"
 #include "range/v3/view/transform.hpp"
 
-namespace org::apache::nifi::minifi::mock {
-struct MockFlowFileData {
-  explicit MockFlowFileData(std::string content_str) {
+struct MinifiFlowFile {
+  explicit MinifiFlowFile(std::string content_str) {
     this->content = content_str
            | ranges::views::transform([](char c) { return static_cast<std::byte>(c); })
            | ranges::to<std::vector<std::byte>>();
   }
 
-  ~MockFlowFileData() = default;
+  ~MinifiFlowFile() = default;
 
-  MockFlowFileData() = default;
-  MockFlowFileData(const MockFlowFileData&) = default;
-  MockFlowFileData(MockFlowFileData&&) = default;
-  MockFlowFileData& operator=(const MockFlowFileData&) = default;
-  MockFlowFileData& operator=(MockFlowFileData&&) = default;
+  MinifiFlowFile() = default;
+  MinifiFlowFile(const MinifiFlowFile&) = default;
+  MinifiFlowFile(MinifiFlowFile&&) = default;
+  MinifiFlowFile& operator=(const MinifiFlowFile&) = default;
+  MinifiFlowFile& operator=(MinifiFlowFile&&) = default;
 
   std::map<std::string, std::string> attributes;
   std::vector<std::byte> content;
   bool is_penalized = false;
   std::string id;
 };
 
+namespace org::apache::nifi::minifi::mock {
+
 class MockProcessSession : public api::core::ProcessSession {
  public:
   MockProcessSession() = default;
@@ -54,8 +55,6 @@ class MockProcessSession : public api::core::ProcessSession {
   MockProcessSession(MockProcessSession&&) = delete;
   MockProcessSession& operator=(MockProcessSession&&) = delete;
 
-  ~MockProcessSession() override;
-
   api::core::FlowFile create(const api::core::FlowFile* parent) override;
   api::core::FlowFile get() override;
   void penalize(api::core::FlowFile& ff) override;
@@ -70,13 +69,12 @@ class MockProcessSession : public api::core::ProcessSession {
   [[nodiscard]] std::string getFlowFileId(const api::core::FlowFile& ff) const override;
   [[nodiscard]] uint64_t getFlowFileSize(const api::core::FlowFile& ff) const override;
 
-  void addInputFlowFile(MockFlowFileData flow_file_data);
+  void addInputFlowFile(std::unique_ptr<MinifiFlowFile> flow_file);
 
  private:
-  std::vector<api::core::FlowFile> input_flow_files_;
-  std::map<MinifiFlowFile*, MockFlowFileData> flow_file_datas;
-  std::map<std::string, std::vector<api::core::FlowFile>> transferred_flow_files_;
-  std::vector<api::core::FlowFile> removed_flow_files_;
+  std::vector<std::unique_ptr<MinifiFlowFile>> input_flow_files_;
+  std::map<std::string, std::vector<std::unique_ptr<MinifiFlowFile>>> transferred_flow_files_;
+  std::vector<std::unique_ptr<MinifiFlowFile>> removed_flow_files_;
 };
 
 }  // namespace org::apache::nifi::minifi::mock

extension-framework/cpp-extension-lib/mocklib/include/MockUtils.h

@@ -22,8 +22,6 @@
 #include "MockLogger.h"
 #include "minifi-cpp/core/ProcessorMetadata.h"
 
-struct MinifiFlowFile{};
-
 namespace org::apache::nifi::minifi::mock {
 inline core::ProcessorMetadata getMockMetadata() {
   return core::ProcessorMetadata{.uuid = utils::Identifier{}, .name = "Processor", .logger = std::make_shared<MockLogger>()};

extension-framework/cpp-extension-lib/mocklib/src/MockProcessSession.cpp

@@ -21,90 +21,68 @@
 
 namespace org::apache::nifi::minifi::mock {
 
-MockProcessSession::~MockProcessSession() {
-  // api::core::FlowFile requires that somebody takes ownership before it goes out of scope
-  // the tested processor should either remove or transfer all FlowFiles it handles
-  for (auto& ff : removed_flow_files_) {
-    delete ff.release();  // NOLINT(cppcoreguidelines-owning-memory)
-  }
-  for (auto& ffs : transferred_flow_files_ | std::views::values) {
-    for (auto& ff : ffs) {
-      delete ff.release();  // NOLINT(cppcoreguidelines-owning-memory)
-    }
-  }
-}
-
 api::core::FlowFile MockProcessSession::create(const api::core::FlowFile*) {
   auto new_ff = api::core::FlowFile{new MinifiFlowFile};  // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-  flow_file_datas[new_ff.get()];
   return new_ff;
 }
 api::core::FlowFile MockProcessSession::get() {
   if (input_flow_files_.empty()) { return nullptr; }
 
   auto ff = std::move(input_flow_files_.back());
   input_flow_files_.pop_back();
-  flow_file_datas[ff.get()];
 
-  return ff;
+  return api::core::FlowFile{ff.release()};
 }
 
 void MockProcessSession::penalize(api::core::FlowFile& ff) {
-  auto& flow_file_data = flow_file_datas.at(ff.get());
-  flow_file_data.is_penalized = true;
+  ff->is_penalized = true;
 }
 
 void MockProcessSession::transfer(api::core::FlowFile ff, const minifi::core::Relationship& relationship) {
-  transferred_flow_files_[relationship.getName()].push_back(std::move(ff));
+  transferred_flow_files_[relationship.getName()].push_back(std::unique_ptr<MinifiFlowFile>(ff.release()));
 }
 
 void MockProcessSession::remove(api::core::FlowFile ff) {
-  removed_flow_files_.push_back(std::move(ff));
+  removed_flow_files_.push_back(std::unique_ptr<MinifiFlowFile>(ff.release()));
 }
 
 void MockProcessSession::write(api::core::FlowFile& ff, const io::OutputStreamCallback& callback) {
-  auto& flow_file_data = flow_file_datas.at(ff.get());
-  const auto stream = std::make_shared<MockOutputStream>(flow_file_data.content);
+  const auto stream = std::make_shared<MockOutputStream>(ff->content);
   callback(stream);
 }
 
 void MockProcessSession::read(api::core::FlowFile& ff, const io::InputStreamCallback& callback) {
-  auto& flow_file_data = flow_file_datas.at(ff.get());
-  const auto stream = std::make_shared<MockInputStream>(flow_file_data.content);
+  const auto stream = std::make_shared<MockInputStream>(ff->content);
   callback(stream);
 }
 
 void MockProcessSession::setAttribute(api::core::FlowFile& ff, std::string_view key, std::string value) {
-  auto& attributes = flow_file_datas.at(ff.get()).attributes;
-  attributes[std::string(key)] = std::move(value);
+  ff->attributes[std::string(key)] = std::move(value);
 }
 
 void MockProcessSession::removeAttribute(api::core::FlowFile& ff, std::string_view key) {
-  auto& attributes = flow_file_datas.at(ff.get()).attributes;
-  attributes.erase(std::string(key));
+  ff->attributes.erase(std::string(key));
 }
 
 std::optional<std::string> MockProcessSession::getAttribute(api::core::FlowFile& ff, std::string_view key) {
-  auto& attributes = flow_file_datas.at(ff.get()).attributes;
+  auto& attributes = ff->attributes;
   if (const auto it = attributes.find(std::string(key)); it != attributes.end()) { return it->second; }
   return std::nullopt;
 }
 
 std::map<std::string, std::string> MockProcessSession::getAttributes(const api::core::FlowFile& ff) const {
-  return flow_file_datas.at(ff.get()).attributes;
+  return ff->attributes;
 }
 
 std::string MockProcessSession::getFlowFileId(const api::core::FlowFile& ff) const {
-  return flow_file_datas.at(ff.get()).id;
+  return ff->id;
 }
 
 uint64_t MockProcessSession::getFlowFileSize(const api::core::FlowFile& ff) const {
-  return flow_file_datas.at(ff.get()).content.size();
+  return ff->content.size();
 }
 
-void MockProcessSession::addInputFlowFile(MockFlowFileData flow_file_data) {
-  auto new_ff = api::core::FlowFile{new MinifiFlowFile};  // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-  flow_file_datas.emplace(new_ff.get(), std::move(flow_file_data));
-  input_flow_files_.push_back(std::move(new_ff));
+void MockProcessSession::addInputFlowFile(std::unique_ptr<MinifiFlowFile> flow_file) {
+  input_flow_files_.push_back(std::move(flow_file));
 }
 }  // namespace org::apache::nifi::minifi::mock