Added first receiver test

common/cpp/include/common/error.h

@@ -32,7 +32,9 @@ class ErrorInterface {
     virtual ~ErrorInterface() = default; // needed for unique_ptr to delete itself
     /*TODO: Add these function, so it will be really easy and convenient to use the error class
      * virtual inline bool operator == (const Error& rhs) const
+     * virtual inline bool operator != (const Error& rhs) const
      * virtual inline bool operator == (const ErrorTemplateInterface& rhs) const
+     * virtual inline bool operator != (const ErrorTemplateInterface& rhs) const
      * virtual inline bool bool() const;
      * virtual inline bool operator = (const ErrorTemplateInterface& rhs) const
      */
@@ -42,6 +44,9 @@ class ErrorTemplateInterface {
   public:
     virtual ErrorType GetErrorType() const noexcept = 0;
     virtual Error Generate() const noexcept = 0;
+    /*TODO: Add these function, so it will be really easy and convenient to use the error class
+     * virtual inline bool operator ErrorTemplateInterface() const
+     */
 
     virtual inline bool operator == (const Error* rhs) const {
         return rhs != nullptr &&
@@ -63,6 +68,14 @@ class ErrorTemplateInterface {
     }
 };
 
+static inline bool operator == (const Error& lhs, const ErrorTemplateInterface& rhs) {
+    return rhs.operator==(lhs);
+}
+
+static inline bool operator != (const Error& lhs, const ErrorTemplateInterface& rhs) {
+    return rhs.operator!=(lhs);
+}
+
 class SimpleError: public ErrorInterface {
   private:
     std::string error_;

common/cpp/include/system_wrappers/io.h

@@ -70,7 +70,7 @@ class IOErrorTemplate : public SimpleErrorTemplate {
 };
 
 namespace IOErrorTemplates {
-auto const kUnknownError = IOErrorTemplate{"Unknown Error", IOErrorType::kUnknownIOError};
+auto const kUnknownIOError = IOErrorTemplate{"Unknown Error", IOErrorType::kUnknownIOError};
 
 auto const kFileNotFound = IOErrorTemplate{"No such file or directory", IOErrorType::kFileNotFound};
 auto const kReadError = IOErrorTemplate{"Read error", IOErrorType::kFileNotFound};

common/cpp/src/system_io/system_io.cpp

@@ -366,13 +366,13 @@ SocketDescriptor SystemIO::CreateSocket(AddressFamilies address_family,
 
     int type = SocketTypeToPosixType(socket_type);
     if(type == -1) {
-        *err = IOErrorTemplates::kUnknownError.Generate();
+        *err = IOErrorTemplates::kUnknownIOError.Generate();
         return -1;
     }
 
     int protocol = SocketProtocolToPosixProtocol(socket_protocol);
     if(protocol == -1) {
-        *err = IOErrorTemplates::kUnknownError.Generate();
+        *err = IOErrorTemplates::kUnknownIOError.Generate();
         return -1;
     }
 
@@ -485,7 +485,7 @@ size_t SystemIO::Transfer(ssize_t (* method)(FileDescriptor, void*, size_t), Fil
                 continue;
             }
             if(*err == nullptr) {
-                *err = IOErrorTemplates::kUnknownError.Generate();
+                *err = IOErrorTemplates::kUnknownIOError.Generate();
             }
             return already_transferred;//Return the amount of _ensured_ transferred bytes
         }

common/cpp/src/system_io/system_io_linux.cpp

@@ -53,7 +53,7 @@ Error GetLastErrorFromErrno() {
         return IOErrorTemplates::kSocketOperationOnNonSocket.Generate();
     default:
         std::cout << "[IOErrorsFromErrno] Unknown error code: " << errno << std::endl;
-        Error err = IOErrorTemplates::kUnknownError.Generate();
+        Error err = IOErrorTemplates::kUnknownIOError.Generate();
         (*err).Append("Unknown error code: " + std::to_string(errno));
         return err;
     }

common/cpp/unittests/common/test_error.cpp

@@ -8,19 +8,19 @@ using ::testing::Ne;
 
 namespace {
 
-    TEST(ErrorTemplate, GenerateNoNullptr) {
-        Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
-        ASSERT_THAT(error, Ne(nullptr));
-    }
+TEST(ErrorTemplate, GenerateNoNullptr) {
+    Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
+    ASSERT_THAT(error, Ne(nullptr));
+}
 
-    TEST(ErrorTemplate, EqCheck) {
-        Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
-        ASSERT_TRUE(hidra2::ErrorTemplates::kEndOfFile == error);
-    }
+TEST(ErrorTemplate, EqCheck) {
+    Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
+    ASSERT_TRUE(hidra2::ErrorTemplates::kEndOfFile == error);
+}
 
 
-    TEST(ErrorTemplate, NeCheck) {
-        Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
-        ASSERT_FALSE(hidra2::ErrorTemplates::kMemoryAllocationError == error);
-    }
+TEST(ErrorTemplate, NeCheck) {
+    Error error = hidra2::ErrorTemplates::kEndOfFile.Generate();
+    ASSERT_FALSE(hidra2::ErrorTemplates::kMemoryAllocationError == error);
+}
 }

producer/api/src/producer_impl.cpp

@@ -72,7 +72,7 @@ hidra2::ProducerError hidra2::ProducerImpl::Send(uint64_t file_id, const void* d
 
     SendDataRequest sendDataRequest;
     sendDataRequest.op_code = kNetOpcodeSendData;
-    sendDataRequest.request_id = request_id++;
+    sendDataRequest.request_id = request_id_++;
     sendDataRequest.file_id = file_id;
     sendDataRequest.file_size = file_size;
 

producer/api/src/producer_impl.h

@@ -12,7 +12,7 @@ class ProducerImpl : public Producer, public HasIO {
     static const uint32_t kVersion;
 
     int         client_fd_ = -1;
-    uint64_t    request_id = 0;
+    uint64_t    request_id_ = 0;
 
     ProducerStatus status_ = ProducerStatus::kDisconnected;
 

producer/api/unittests/test_producer_impl.cpp

@@ -91,7 +91,7 @@ TEST(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_unk) {
     .Times(1)
     .WillOnce(
         DoAll(
-            testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownError.Generate().release()),
+            testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
             Return(-1)
         ));
 

receiver/CMakeLists.txt

 set(TARGET_NAME receiver)
 set(SOURCE_FILES
-        src/main.cpp
         src/receiver.h src/receiver.cpp
         src/network_producer_peer.h src/network_producer_peer.cpp src/network_producer_peer_handlers.cpp
         )
@@ -9,26 +8,29 @@ set(SOURCE_FILES
 ################################
 # Library
 ################################
-add_executable(${TARGET_NAME} ${SOURCE_FILES} $<TARGET_OBJECTS:system_io>)
-target_include_directories(${TARGET_NAME} PUBLIC include)
+add_library(${TARGET_NAME} STATIC ${SOURCE_FILES} $<TARGET_OBJECTS:system_io>)
 set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 target_include_directories(${TARGET_NAME} PUBLIC ${HIDRA2_CXX_COMMON_INCLUDE_DIR})
 
+add_executable(${TARGET_NAME}-bin src/main.cpp)
+set_target_properties(${TARGET_NAME}-bin PROPERTIES OUTPUT_NAME ${TARGET_NAME})
+target_link_libraries(${TARGET_NAME}-bin ${TARGET_NAME})
+
 #Add all necessary common libraries
 GET_PROPERTY(HIDRA2_COMMON_IO_LIBRARIES GLOBAL PROPERTY HIDRA2_COMMON_IO_LIBRARIES)
-target_link_libraries(${TARGET_NAME} ${HIDRA2_COMMON_IO_LIBRARIES})
-set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
-
+target_link_libraries(${TARGET_NAME}-bin ${HIDRA2_COMMON_IO_LIBRARIES})
+set_target_properties(${TARGET_NAME}-bin PROPERTIES LINKER_LANGUAGE CXX)
 
 ################################
 # Testing
 ################################
 
-#set_property(TARGET ${TARGET_NAME} PROPERTY ENABLE_EXPORTS true)
+set_property(TARGET ${TARGET_NAME} PROPERTY ENABLE_EXPORTS true)
 #
-#set(TEST_SOURCE_FILES
-#        unittests/test_receiver.cpp
-#        )
+set(TEST_SOURCE_FILES
+        unittests/test_receiver.cpp
+        unittests/test_network_producer_peer.cpp
+        )
 #
-#set(TEST_LIBRARIES "${TARGET_NAME} common")
-#gtest(${TARGET_NAME} "${TEST_SOURCE_FILES}" "${TEST_LIBRARIES}")
+set(TEST_LIBRARIES "${TARGET_NAME};system_io")
+gtest(${TARGET_NAME} "${TEST_SOURCE_FILES}" "${TEST_LIBRARIES}")

receiver/src/network_producer_peer.cpp

@@ -4,7 +4,7 @@
 
 namespace hidra2 {
 
-const size_t NetworkProducerPeer::kGenericBufferSize = 1024 * 50; //50KiByte
+size_t NetworkProducerPeer::kRequestHandlerMaxBufferSize;
 std::atomic<uint32_t> NetworkProducerPeer::kNetworkProducerPeerCount;
 
 const std::vector<NetworkProducerPeer::RequestHandlerInformation> NetworkProducerPeer::kRequestHandlers =
@@ -15,7 +15,7 @@ NetworkProducerPeer::NetworkProducerPeer(int socket_fd, std::string address) : H
     connection_id_ = kNetworkProducerPeerCount++;
 }
 
-uint32_t NetworkProducerPeer::connection_id() const {
+uint32_t NetworkProducerPeer::GetConnectionId() const {
     return connection_id_;
 }
 
@@ -29,14 +29,11 @@ void NetworkProducerPeer::start_peer_listener() {
 }
 
 void NetworkProducerPeer::internal_receiver_thread_() {
-    auto* const generic_request = (GenericNetworkRequest*) malloc(kGenericBufferSize);
-    auto* const generic_response = (GenericNetworkResponse*) malloc(kGenericBufferSize);
-
     Error io_err;
     while(is_listening_) {
         io_err = nullptr;
 
-        size_t size = io->ReceiveWithTimeout(socket_fd_, generic_request, sizeof(GenericNetworkRequest), 50, &io_err);
+        io->ReceiveWithTimeout(socket_fd_, generic_request, sizeof(GenericNetworkRequest), 50, &io_err);
         if(io_err != nullptr) {
             if(IOErrorTemplates::kTimeout == io_err) {
                 std::this_thread::yield();
@@ -48,14 +45,12 @@ void NetworkProducerPeer::internal_receiver_thread_() {
                 break;
             }
 
-            std::cerr << "[" << connection_id() << "] Fail to receive data" << std::endl;
+            std::cerr << "[" << GetConnectionId() << "] Fail to receive data" << std::endl;
             is_listening_ = false;
             break;
         }
 
-        assert(size);//Something in ReceiveWithTimeout went wrong.
-
-        std::cout << "[" << connection_id() << "] Got request: " << generic_request->op_code << std::endl;
+        std::cout << "[" << GetConnectionId() << "] Got request: " << generic_request->op_code << std::endl;
         size_t bytes_to_send = handle_generic_request_(generic_request, generic_response);
 
         if(bytes_to_send == 0) {
@@ -65,12 +60,12 @@ void NetworkProducerPeer::internal_receiver_thread_() {
         io->Send(socket_fd_, generic_response, bytes_to_send, &io_err);
 
         if(io_err != nullptr) {
-            std::cerr << "[" << connection_id() << "] Fail to send response" << std::endl;
+            std::cerr << "[" << GetConnectionId() << "] Fail to send response" << std::endl;
         }
     }
 
     io->CloseSocket(socket_fd_, nullptr);
-    std::cout << "[" << connection_id() << "] Disconnected." << std::endl;
+    std::cout << "[" << GetConnectionId() << "] Disconnected." << std::endl;
 
     free(generic_request);
     free(generic_response);
@@ -87,7 +82,7 @@ void NetworkProducerPeer::stop_peer_listener() {
 
 size_t NetworkProducerPeer::handle_generic_request_(GenericNetworkRequest* request, GenericNetworkResponse* response) {
     if(request->op_code >= kNetOpcodeCount || request->op_code < 0) {
-        std::cerr << "[" << connection_id() << "] Error invalid op_code: " << request->op_code << " force disconnect." <<
+        std::cerr << "[" << GetConnectionId() << "] Error invalid op_code: " << request->op_code << " force disconnect." <<
                   std::endl;
         io->CloseSocket(socket_fd_, nullptr);
         return 0;
@@ -98,18 +93,15 @@ size_t NetworkProducerPeer::handle_generic_request_(GenericNetworkRequest* reque
 
     auto handler_information = kRequestHandlers[request->op_code];
 
-    assert(handler_information.request_size <= kGenericBufferSize);//Would overwrite arbitrary memory
-    assert(handler_information.response_size <= kGenericBufferSize);//Would overwrite arbitrary memory
-
     Error io_err;
 
     static const size_t sizeof_generic_request = sizeof(GenericNetworkRequest);
     //receive the rest of the message
-    size_t rec = io->Receive(socket_fd_, (uint8_t*)request + sizeof_generic_request,
+    io->Receive(socket_fd_, (uint8_t*)request + sizeof_generic_request,
                              handler_information.request_size - sizeof_generic_request, &io_err);
 
     if(io_err != nullptr) {
-        std::cerr << "[" << connection_id() << "] NetworkProducerPeer::handle_generic_request_/receive_timeout: " <<
+        std::cerr << "[" << GetConnectionId() << "] NetworkProducerPeer::handle_generic_request_/receive_timeout: " <<
                   request->op_code << std::endl;
         return 0;
     }
@@ -125,13 +117,17 @@ NetworkProducerPeer::~NetworkProducerPeer() {
 
 FileDescriptor NetworkProducerPeer::CreateAndOpenFileByFileId(uint64_t file_id, Error* err) {
     io->CreateNewDirectory("files", err);
-    if(*err != nullptr && IOErrorTemplates::kFileAlreadyExists == *err) {
+    if(*err != nullptr && *err != IOErrorTemplates::kFileAlreadyExists) {
         return -1;
     }
     return io->Open("files/" + std::to_string(file_id) + ".bin", IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS | IO_OPEN_MODE_RW,
                     err);
 }
 
+bool NetworkProducerPeer::CheckIfValidFileSize(size_t file_size) {
+    return file_size != 0 && file_size <= size_t(1024)*1024*1024*2;
+
+}
 
 }
 

receiver/src/network_producer_peer.h

@@ -13,7 +13,7 @@
 
 namespace hidra2 {
 
-class NetworkProducerPeer : HasIO {
+class NetworkProducerPeer : public HasIO {
   public:
     typedef void (*RequestHandler) (NetworkProducerPeer* self, GenericNetworkRequest* request,
                                     GenericNetworkResponse* response);
@@ -23,12 +23,15 @@ class NetworkProducerPeer : HasIO {
         RequestHandler handler;
     };
   private:
-    /** Must be as large as the largest request type (not including the data) */
-    static const size_t kGenericBufferSize;
-
     static const std::vector<RequestHandlerInformation> kRequestHandlers;
+    static size_t kRequestHandlerMaxBufferSize;
+
     static std::atomic<uint32_t> kNetworkProducerPeerCount;
 
+
+    GenericNetworkRequest* const generic_request = reinterpret_cast<GenericNetworkRequest* const>(new uint8_t[kRequestHandlerMaxBufferSize]);
+    GenericNetworkResponse* const generic_response = reinterpret_cast<GenericNetworkResponse* const>(new uint8_t[kRequestHandlerMaxBufferSize]);
+
     uint32_t                        connection_id_;
     int                             socket_fd_;
 
@@ -40,9 +43,6 @@ class NetworkProducerPeer : HasIO {
 
     static void handle_send_data_request_(NetworkProducerPeer* self, const SendDataRequest* request,
                                           SendDataResponse* response);
-
-    FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err);
-
   public:
     NetworkProducerPeer& operator=(const NetworkProducerPeer&) = delete;
     NetworkProducerPeer() = default;
@@ -52,11 +52,15 @@ class NetworkProducerPeer : HasIO {
 
     static const std::vector<RequestHandlerInformation> init_request_handlers();
 
-
     void start_peer_listener();
     void stop_peer_listener();
 
-    uint32_t connection_id() const;
+    uint32_t GetConnectionId() const;
+
+    //TODO make the following functions private or hide them behind an interface
+    FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err);
+    static bool CheckIfValidFileSize(size_t file_size);
+
 };
 
 }

receiver/src/network_producer_peer_handlers.cpp

@@ -7,12 +7,24 @@ namespace hidra2 {
 const std::vector<NetworkProducerPeer::RequestHandlerInformation> NetworkProducerPeer::init_request_handlers() {
     std::vector<NetworkProducerPeer::RequestHandlerInformation> vec(kNetOpcodeCount);
 
+    // Add new opcodes here
     vec[kNetOpcodeSendData] = {
         sizeof(SendDataRequest),
         sizeof(SendDataResponse),
         (NetworkProducerPeer::RequestHandler)& NetworkProducerPeer::handle_send_data_request_
     };
 
+    for(RequestHandlerInformation& handler_information : vec) {
+        //Adjust max size needed for a request/response-buffer
+
+        if(handler_information.request_size > kRequestHandlerMaxBufferSize) {
+            kRequestHandlerMaxBufferSize = handler_information.request_size;
+        }
+        if(handler_information.response_size > kRequestHandlerMaxBufferSize) {
+            kRequestHandlerMaxBufferSize = handler_information.response_size;
+        }
+    }
+
     return vec;
 }
 
@@ -21,13 +33,7 @@ void NetworkProducerPeer::handle_send_data_request_(NetworkProducerPeer* self, c
         SendDataResponse* response) {
     Error io_err;
 
-    if (request->file_size == 0) {
-        std::cerr << "[" << self->connection_id() << "] file_id: " << request->file_id << " has size of 0!" << std::endl;
-        response->error_code = NET_ERR__ALLOCATE_STORAGE_FAILED;
-        return;
-    }
-
-    if(request->file_size > size_t(1024)*size_t(1024)*size_t(1024)*size_t(2)/*2GiByte*/) {
+    if(!CheckIfValidFileSize(request->file_size)) {
         response->error_code = NET_ERR__ALLOCATE_STORAGE_FAILED;
         return;
     }
@@ -35,10 +41,10 @@ void NetworkProducerPeer::handle_send_data_request_(NetworkProducerPeer* self, c
     FileDescriptor fd = self->CreateAndOpenFileByFileId(request->file_id, &io_err);
     if(io_err != nullptr) {
         response->error_code = NET_ERR__FILEID_ALREADY_IN_USE;
-        std::cerr << "[" << self->connection_id() << "] file_id: " << request->file_id << " does already exists" << std::endl;
+        std::cerr << "[" << self->GetConnectionId() << "] file_id: " << request->file_id << " does already exists" << std::endl;
         self->io->Skip(self->socket_fd_, request->file_size, &io_err);
         if(io_err != nullptr) {
-            std::cout << "[" << self->connection_id() << "] Out of sync force disconnect" << std::endl;
+            std::cout << "[" << self->GetConnectionId() << "] Out of sync force disconnect" << std::endl;
             self->io->CloseSocket(self->socket_fd_, nullptr);
         }
         return;
@@ -48,7 +54,7 @@ void NetworkProducerPeer::handle_send_data_request_(NetworkProducerPeer* self, c
     try {
         buffer.reset(new uint8_t[request->file_size]);
     } catch(std::exception& e) {
-        std::cerr << "[" << self->connection_id() << "] Failed to allocate enough memory. file_id: " << request->file_id <<
+        std::cerr << "[" << self->GetConnectionId() << "] Failed to allocate enough memory. file_id: " << request->file_id <<
                   " file_size:" << request->file_size << std::endl;
         std::cerr << e.what() << std::endl;
         response->error_code = NET_ERR__INTERNAL_SERVER_ERROR;
@@ -57,14 +63,14 @@ void NetworkProducerPeer::handle_send_data_request_(NetworkProducerPeer* self, c
 
     self->io->Receive(self->socket_fd_, buffer.get(), request->file_size, &io_err);
     if(io_err != nullptr) {
-        std::cerr << "[" << self->connection_id() << "] An IO error occurred while receiving the file" << std::endl;
+        std::cerr << "[" << self->GetConnectionId() << "] An IO error occurred while receiving the file" << std::endl;
         response->error_code = NET_ERR__INTERNAL_SERVER_ERROR;
         return;
     }
 
     self->io->Write(fd, buffer.get(), request->file_size, &io_err);
     if(io_err != nullptr) {
-        std::cerr << "[" << self->connection_id() << "] An IO error occurred while writing the file" << std::endl;
+        std::cerr << "[" << self->GetConnectionId() << "] An IO error occurred while writing the file" << std::endl;
         response->error_code = NET_ERR__INTERNAL_SERVER_ERROR;
         return;
     }

receiver/src/receiver.cpp

@@ -46,7 +46,7 @@ void hidra2::Receiver::StartListener(std::string listener_address, ReceiverError
     listener_fd_ = listener_fd;
 
     accept_thread_ = io->NewThread([this] {
-        AcceptThreadLogic();//TODO add peer to some list
+        AcceptThreadLogic();
     });
 
 }
@@ -79,7 +79,7 @@ void hidra2::Receiver::StopListener(ReceiverError* err) {
 std::unique_ptr<hidra2::NetworkProducerPeer> hidra2::Receiver::on_new_peer_(int peer_socket_fd, std::string address) {
     NetworkProducerPeer* peer = new NetworkProducerPeer(peer_socket_fd, address);
 
-    std::cout << "[" << peer->connection_id() << "] New connection from " << address << std::endl;
+    std::cout << "[" << peer->GetConnectionId() << "] New connection from " << address << std::endl;
 
     peer->start_peer_listener();
 

receiver/src/receiver.h

@@ -27,7 +27,7 @@ class Receiver : public HasIO {
     std::unique_ptr<NetworkProducerPeer> on_new_peer_(int peer_socket_fd, std::string address);
 
   public:
-    static const int kMaxUnacceptedConnectionsBacklog;
+    static const int kMaxUnacceptedConnectionsBacklog;//TODO: Read from config
 
     Receiver(const Receiver&) = delete;
     Receiver& operator=(const Receiver&) = delete;

receiver/unittests/test_network_producer_peer.cpp

+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <unittests/MockIO.h>
+#include "../src/receiver.h"
+
+using ::testing::Return;
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SetArgReferee;
+using ::testing::Gt;
+using ::testing::Eq;
+using ::testing::Mock;
+using ::testing::InSequence;
+
+namespace {
+
+TEST(CheckIfValidFileSize, ZeroFileSize) {
+    EXPECT_FALSE(hidra2::NetworkProducerPeer::CheckIfValidFileSize(0));
+}
+
+TEST(CheckIfValidFileSize, SmallFileSize) {
+    EXPECT_TRUE(hidra2::NetworkProducerPeer::CheckIfValidFileSize(1));
+}
+
+TEST(CheckIfValidFileSize, OneGiByteSize) {
+    EXPECT_TRUE(hidra2::NetworkProducerPeer::CheckIfValidFileSize(1024*1024*1024*1));
+}
+
+TEST(CheckIfValidFileSize, TwoGiByteSize) {
+    EXPECT_TRUE(hidra2::NetworkProducerPeer::CheckIfValidFileSize(size_t(1024)*1024*1024*2));
+}
+
+TEST(CheckIfValidFileSize, MoreThenTwoGiByteSize) {
+    EXPECT_FALSE(hidra2::NetworkProducerPeer::CheckIfValidFileSize(size_t(1024)*1024*1024*2+1));
+}
+
+TEST(CreateAndOpenFileByFileId, FolderUnknownIOError) {
+    hidra2::NetworkProducerPeer networkProducerPeer;
+    hidra2::MockIO mockIO;
+    networkProducerPeer.__set_io(&mockIO);
+
+    uint64_t expected_file_id = 5435452453867;
+
+    hidra2::Error err;
+    EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
+        .Times(1)
+        .WillOnce(
+                testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
+            );
+    networkProducerPeer.CreateAndOpenFileByFileId(expected_file_id, &err);
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
+}
+
+TEST(CreateAndOpenFileByFileId, FolderAlreadyExsistsButFileAlreadyExists) {
+    hidra2::NetworkProducerPeer networkProducerPeer;
+    hidra2::MockIO mockIO;
+    networkProducerPeer.__set_io(&mockIO);
+
+    uint64_t expected_file_id = 543545;
+    uint64_t expected_fd = 23432;
+
+    hidra2::Error err;
+    EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
+        .Times(1)
+        .WillOnce(
+            testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
+        );
+
+    EXPECT_CALL(mockIO, Open_t(
+                               "files/" + std::to_string(expected_file_id) + ".bin",
+                               hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+                               hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+        .Times(1)
+        .WillOnce(
+            DoAll(
+                testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+                testing::Return(expected_fd)
+            )
+        );
+
+    hidra2::FileDescriptor fd = networkProducerPeer.CreateAndOpenFileByFileId(expected_file_id, &err);
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kFileAlreadyExists));
+    ASSERT_THAT(fd, Eq(expected_fd));
+}
+
+TEST(CreateAndOpenFileByFileId, FolderCreatedButFileAlreadyExists) {
+    hidra2::NetworkProducerPeer networkProducerPeer;
+    hidra2::MockIO mockIO;
+    networkProducerPeer.__set_io(&mockIO);
+
+    uint64_t expected_file_id = 543545;
+
+    hidra2::Error err;
+    EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
+        .Times(1)
+        .WillOnce(
+            testing::SetArgPointee<1>(nullptr)
+        );
+
+    EXPECT_CALL(mockIO, Open_t(
+        "files/" + std::to_string(expected_file_id) + ".bin",
+        hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+            hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+        .Times(1)
+        .WillOnce(
+            DoAll(
+                testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+                testing::Return(-1)
+            )
+        );
+
+    hidra2::FileDescriptor fd = networkProducerPeer.CreateAndOpenFileByFileId(expected_file_id, &err);
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kFileAlreadyExists));
+    ASSERT_THAT(fd, Eq(-1));
+}
+
+TEST(CreateAndOpenFileByFileId, Ok) {
+    hidra2::NetworkProducerPeer networkProducerPeer;
+    hidra2::MockIO mockIO;
+    networkProducerPeer.__set_io(&mockIO);
+
+    uint64_t expected_file_id = 543545;
+    uint64_t expected_fd = 23432;
+
+    hidra2::Error err;
+    EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
+        .Times(1)
+        .WillOnce(
+            testing::SetArgPointee<1>(nullptr)
+        );
+
+    EXPECT_CALL(mockIO, Open_t(
+        "files/" + std::to_string(expected_file_id) + ".bin",
+        hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+            hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+        .Times(1)
+        .WillOnce(
+            DoAll(
+                testing::SetArgPointee<2>(nullptr),
+                testing::Return(expected_fd)
+            )
+        );
+
+    hidra2::FileDescriptor fd = networkProducerPeer.CreateAndOpenFileByFileId(expected_file_id, &err);
+    ASSERT_THAT(err, Eq(nullptr));
+    ASSERT_THAT(fd, Eq(expected_fd));
+}
+
+}

receiver/unittests/test_receiver.cpp

@@ -37,7 +37,7 @@ TEST(a, b) {
     .Times(1)
     .WillOnce(
     DoAll(
-    testing::SetArgPointee<3>(hidra2::IOErrors::kUnknownError),
+    testing::SetArgPointee<3>(hidra2::IOErrors::kUnknownIOError),
     Return(-1)
     ));
 

worker/api/cpp/unittests/test_folder_broker.cpp

@@ -67,7 +67,7 @@ class IOFolderNotFound: public FakeIO {
 class IOFolderUnknownError: public FakeIO {
   public:
     FileInfos FilesInFolder(const std::string& folder, Error* err) const override {
-        *err  = hidra2::IOErrorTemplates::kUnknownError.Generate();
+        *err  = hidra2::IOErrorTemplates::kUnknownIOError.Generate();
         return {};
     }
 };
@@ -129,7 +129,7 @@ TEST_F(FolderDataBrokerTests, ConnectReturnsUnknownIOError) {
 
     auto return_code = data_broker->Connect();
 
-    ASSERT_THAT(return_code->Explain(), Eq(hidra2::IOErrorTemplates::kUnknownError.Generate()->Explain()));
+    ASSERT_THAT(return_code->Explain(), Eq(hidra2::IOErrorTemplates::kUnknownIOError.Generate()->Explain()));
 }
 
 TEST_F(FolderDataBrokerTests, GetNextWithoutConnectReturnsError) {