start working at file write handler

receiver/CMakeLists.txt

@@ -4,6 +4,7 @@ set(SOURCE_FILES
         src/connection.h src/connection.cpp
         src/receiver_error.h
         src/request.cpp
+        src/request_handler_file_write.cpp
         )
 
 
@@ -33,6 +34,7 @@ set(TEST_SOURCE_FILES
         unittests/test_receiver.cpp
         unittests/test_connection.cpp
         unittests/test_request.cpp
+        unittests/test_request_handler_file_write.cpp
         )
 #
 set(TEST_LIBRARIES "${TARGET_NAME};system_io")

receiver/src/request.cpp

@@ -45,6 +45,11 @@ Error Request::Handle() {
     return nullptr;
 }
 
+const RequestHandlerList& Request::GetListHandlers() const {
+    return handlers_;
+}
+
+
 void Request::AddHandler(const RequestHandler* handler) {
     handlers_.emplace_back(handler);
 }
@@ -55,8 +60,11 @@ std::unique_ptr<Request> RequestFactory::GenerateRequest(const GenericNetworkReq
         Error* err) const noexcept {
     *err = nullptr;
     switch (request_header.op_code) {
-    case Opcode::kNetOpcodeSendData:
-        return std::unique_ptr<Request> {new Request{request_header, socket_fd}};
+    case Opcode::kNetOpcodeSendData: {
+        auto request = std::unique_ptr<Request> {new Request{request_header, socket_fd}};
+        request->AddHandler(&request_handler_filewrite_);
+        return request;
+    }
     default:
         *err = ReceiverErrorTemplates::kInvalidOpCode.Generate();
         return nullptr;

receiver/src/request.h

@@ -5,9 +5,11 @@
 #include "common/networking.h"
 #include "system_wrappers/io.h"
 #include "request_handler.h"
+#include "request_handler_file_write.h"
+
 namespace hidra2 {
 
-class RequestHandler;
+using RequestHandlerList = std::vector<const RequestHandler*>;
 
 class Request {
   public:
@@ -15,6 +17,7 @@ class Request {
     virtual ~Request() = default;
     Request(const GenericNetworkRequestHeader& request_header, SocketDescriptor socket_fd);
     void AddHandler(const RequestHandler*);
+    const RequestHandlerList& GetListHandlers() const;
     std::unique_ptr<IO> io__;
   private:
     Error AllocateDataBuffer();
@@ -22,13 +25,15 @@ class Request {
     const GenericNetworkRequestHeader request_header_;
     const SocketDescriptor socket_fd_;
     FileData data_buffer_;
-    std::vector<const RequestHandler*> handlers_;
+    RequestHandlerList handlers_;
 };
 
 class RequestFactory {
   public:
     virtual std::unique_ptr<Request> GenerateRequest(const GenericNetworkRequestHeader& request_header,
-                                                     SocketDescriptor socket_fd, Error* err) const noexcept ;
+                                                     SocketDescriptor socket_fd, Error* err) const noexcept;
+  private:
+    RequestHandlerFileWrite request_handler_filewrite_;
 };
 
 }

receiver/src/request_handler.h

 #ifndef HIDRA2_REQUEST_HANDLER_H
 #define HIDRA2_REQUEST_HANDLER_H
 
-#include "request.h"
 #include "receiver_error.h"
 
 namespace hidra2 {
@@ -11,6 +10,7 @@ class Request;
 class RequestHandler {
   public:
     virtual Error ProcessRequest(const Request& request) const = 0;
+    virtual ~RequestHandler() = default;
   private:
 };
 

receiver/src/request_handler_file_write.cpp

+#include "request_handler_file_write.h"
+#include "system_wrappers/system_io.h"
+
+namespace hidra2 {
+
+Error RequestHandlerFileWrite::ProcessRequest(const Request& request) const {
+    return nullptr;
+}
+
+RequestHandlerFileWrite::RequestHandlerFileWrite() : io__{new SystemIO} {
+
+}
+
+}

receiver/src/request_handler_file_write.h

+#ifndef HIDRA2_REQUEST_HANDLER_FILE_WRITE_H
+#define HIDRA2_REQUEST_HANDLER_FILE_WRITE_H
+
+#include "request_handler.h"
+
+#include "system_wrappers/io.h"
+
+namespace hidra2 {
+
+class RequestHandlerFileWrite final: public RequestHandler {
+  public:
+    RequestHandlerFileWrite();
+    Error ProcessRequest(const Request& request) const override;
+    std::unique_ptr<IO> io__;
+};
+
+}
+
+#endif //HIDRA2_REQUEST_HANDLER_FILE_WRITE_H

receiver/unittests/test_request.cpp

@@ -5,6 +5,7 @@
 #include "../src/receiver_error.h"
 #include "../src/request.h"
 #include "../src/request_handler.h"
+#include "../src/request_handler_file_write.h"
 
 using ::testing::Test;
 using ::testing::Return;
@@ -61,15 +62,18 @@ TEST_F(FactoryTests, ErrorOnWrongCode) {
     ASSERT_THAT(err, Ne(nullptr));
 }
 
-TEST_F(FactoryTests, ReturnsSendDataRequestOnkNetOpcodeSendDataCode) {
+TEST_F(FactoryTests, ReturnsDataRequestOnkNetOpcodeSendDataCode) {
     generic_request_header.op_code = hidra2::Opcode::kNetOpcodeSendData;
     auto request = factory.GenerateRequest(generic_request_header, 1, &err);
 
     ASSERT_THAT(err, Eq(nullptr));
     ASSERT_THAT(dynamic_cast<hidra2::Request*>(request.get()), Ne(nullptr));
+    ASSERT_THAT(dynamic_cast<const hidra2::RequestHandlerFileWrite*>(request->GetListHandlers()[0]), Ne(nullptr));
 }
 
 
+
+
 class RequestTests : public Test {
   public:
     GenericNetworkRequestHeader generic_request_header;

receiver/unittests/test_request_handler_file_write.cpp

+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <unittests/MockIO.h>
+#include "../src/receiver_error.h"
+#include "../src/request.h"
+#include "../src/request_handler.h"
+#include "../src/request_handler_file_write.h"
+#include "common/networking.h"
+
+using ::testing::Test;
+using ::testing::Return;
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SetArgReferee;
+using ::testing::Gt;
+using ::testing::Eq;
+using ::testing::Ne;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::InSequence;
+using ::testing::SetArgPointee;
+using ::hidra2::Error;
+using ::hidra2::ErrorInterface;
+using ::hidra2::FileDescriptor;
+using ::hidra2::SocketDescriptor;
+using ::hidra2::MockIO;
+using hidra2::Request;
+using hidra2::RequestHandlerFileWrite;
+using ::hidra2::GenericNetworkRequestHeader;
+
+namespace {
+
+class MockRequest: public Request {
+  public:
+    MockRequest(const GenericNetworkRequestHeader& request_header, SocketDescriptor socket_fd):
+        Request(request_header, socket_fd) {};
+
+    MOCK_CONST_METHOD0(GetFileName, std::string());
+    MOCK_CONST_METHOD0(GetDataSize, uint64_t());
+    MOCK_CONST_METHOD0(GetData, const hidra2::FileData & ());
+};
+
+class FileWriteHandlerTests : public Test {
+  public:
+    RequestHandlerFileWrite handler;
+    NiceMock<MockIO> mock_io;
+    void SetUp() override {
+        handler.io__ = std::unique_ptr<hidra2::IO> {&mock_io};
+        /*      ON_CALL(mock_io, Receive_t(socket_fd_, _, data_size_, _)).WillByDefault(
+                  DoAll(SetArgPointee<3>(nullptr),
+                        Return(0)
+                  ));*/
+    }
+    void TearDown() override {
+        handler.io__.release();
+    }
+
+};
+
+}
\ No newline at end of file