diff --git a/common/cpp/include/system_wrappers/has_io.h b/common/cpp/include/system_wrappers/has_io.h
index ac47213fb21e58c4e3410870121ba25ce566a061..b8005abfd8324c86d96b1e1150bb92db3f8d6b46 100644
--- a/common/cpp/include/system_wrappers/has_io.h
+++ b/common/cpp/include/system_wrappers/has_io.h
@@ -14,8 +14,8 @@ class HasIO {
     explicit HasIO();
   public:
 
-    void __set_io(IO* io);
-    IO* __get_io();
+    void SetIO__(IO* io);
+    IO* GetIO__();
 };
 
 }
diff --git a/common/cpp/src/system_io/has_io.cpp b/common/cpp/src/system_io/has_io.cpp
index 932252941e7b41e3eddf5937dd6bd4bc2db7455c..1fe92e1ed137900a9ce058f4fb424656ea12078b 100644
--- a/common/cpp/src/system_io/has_io.cpp
+++ b/common/cpp/src/system_io/has_io.cpp
@@ -7,10 +7,10 @@ hidra2::HasIO::HasIO() {
     io = kDefaultIO;
 }
 
-void hidra2::HasIO::__set_io(hidra2::IO* io) {
+void hidra2::HasIO::SetIO__(hidra2::IO* io) {
     this->io = io;
 }
 
-hidra2::IO* hidra2::HasIO::__get_io() {
+hidra2::IO* hidra2::HasIO::GetIO__() {
     return io;
 }
diff --git a/producer/api/src/producer_impl.cpp b/producer/api/src/producer_impl.cpp
index c289e85616e7dd6103e2b8717f4e2cd76f686427..eb932e65692e8eaf432e0af55c87e082c26eb001 100644
--- a/producer/api/src/producer_impl.cpp
+++ b/producer/api/src/producer_impl.cpp
@@ -17,7 +17,7 @@ hidra2::ProducerError hidra2::ProducerImpl::NetworkErrorToProducerError(hidra2::
 }
 
 hidra2::ProducerImpl::ProducerImpl() {
-    __set_io(ProducerImpl::kDefaultIO);
+    SetIO__(ProducerImpl::kDefaultIO);
 }
 
 uint64_t hidra2::ProducerImpl::GetVersion() const {
diff --git a/producer/api/unittests/test_producer_impl.cpp b/producer/api/unittests/test_producer_impl.cpp
index 1148408cbab224b177c7ebdd6811d0d63506d38e..9478fbe107080e8f297d33e754c719005993d8a6 100644
--- a/producer/api/unittests/test_producer_impl.cpp
+++ b/producer/api/unittests/test_producer_impl.cpp
@@ -36,7 +36,7 @@ TEST(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_invalid_addres
     hidra2::ProducerImpl producer;
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     std::string expected_address = "127.0.0.1:9090";
 
@@ -60,7 +60,7 @@ TEST(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_connection_ref
     hidra2::ProducerImpl producer;
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     std::string expected_address = "127.0.0.1:9090";
 
@@ -83,7 +83,7 @@ TEST(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_unk) {
     hidra2::ProducerImpl producer;
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     std::string expected_address = "127.0.0.1:9090";
 
@@ -106,7 +106,7 @@ TEST(ProducerImpl, ConnectToReceiver) {
     hidra2::ProducerImpl producer;
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     std::string expected_address = "127.0.0.1:9090";
     hidra2::FileDescriptor expected_fd = 199;
@@ -128,7 +128,7 @@ TEST(ProducerImpl, ConnectToReceiver) {
 
 void ConnectToReceiver_DONE(hidra2::ProducerImpl& producer, hidra2::FileDescriptor expected_fd = 1) {
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, CreateAndConnectIPTCPSocket_t(_, _))
     .Times(1)
@@ -147,7 +147,7 @@ TEST(ProducerImpl, ConnectToReceiver__already_connected) {
 
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     InSequence sequence;
 
@@ -214,7 +214,7 @@ TEST(ProducerImpl, Send__sendDataRequest_error) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(expected_fd, M_CheckSendDataRequest(expected_request_id, expected_file_id,
                                expected_file_size),
@@ -246,7 +246,7 @@ TEST(ProducerImpl, Send__sendData_error) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(_, _, _, _))
     .Times(1)
@@ -286,7 +286,7 @@ TEST(ProducerImpl, Send__Receive_error) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(_, _, _, _))
     .Times(2)
@@ -324,7 +324,7 @@ TEST(ProducerImpl, Send__Receive_server_error) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(_, _, _, _))
     .Times(2)
@@ -363,7 +363,7 @@ TEST(ProducerImpl, Send__Receive_server_error_id_already_in_use) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(_, _, _, _))
     .Times(2)
@@ -402,7 +402,7 @@ TEST(ProducerImpl, Send) {
     ConnectToReceiver_DONE(producer, expected_fd);
 
     hidra2::MockIO mockIO;
-    producer.__set_io(&mockIO);
+    producer.SetIO__(&mockIO);
 
     EXPECT_CALL(mockIO, Send_t(_, _, _, _))
     .Times(2)
diff --git a/receiver/src/network_producer_peer.h b/receiver/src/network_producer_peer.h
index 2ce5053789712a6c7da07e9b385ee53e34fd9164..e97a269e0839ef844266665ac352438b6b1b7144 100644
--- a/receiver/src/network_producer_peer.h
+++ b/receiver/src/network_producer_peer.h
@@ -14,8 +14,6 @@
 namespace hidra2 {
 
 class NetworkProducerPeer {
-  protected:
-    virtual void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) = 0;
   public:
     virtual ~NetworkProducerPeer() = default;
 
@@ -25,6 +23,8 @@ class NetworkProducerPeer {
     virtual uint32_t GetConnectionId() const = 0;
     virtual std::string GetAddress() const = 0;
 
+    virtual void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) const noexcept = 0;
+
     static std::unique_ptr<NetworkProducerPeer> CreateNetworkProducerPeer(SocketDescriptor socket_fd,
             const std::string& address);
 };
diff --git a/receiver/src/network_producer_peer_impl.cpp b/receiver/src/network_producer_peer_impl.cpp
index 9d84e3ccf6846293f7bedf3e72c42d7faa4a018d..9b6c42b24e92e712f82794d9d4636f7cd90cd7d7 100644
--- a/receiver/src/network_producer_peer_impl.cpp
+++ b/receiver/src/network_producer_peer_impl.cpp
@@ -134,7 +134,7 @@ NetworkProducerPeerImpl::~NetworkProducerPeerImpl() {
     StopPeerListener();
 }
 
-FileDescriptor NetworkProducerPeerImpl::CreateAndOpenFileByFileId(uint64_t file_id, Error* err) {
+FileDescriptor NetworkProducerPeerImpl::CreateAndOpenFileByFileId(uint64_t file_id, Error* err) const noexcept {
     io->CreateNewDirectory("files", err);
     if(*err && *err != IOErrorTemplates::kFileAlreadyExists) {
         return -1;
@@ -143,11 +143,11 @@ FileDescriptor NetworkProducerPeerImpl::CreateAndOpenFileByFileId(uint64_t file_
                     err);
 }
 
-bool NetworkProducerPeerImpl::CheckIfValidFileSize(size_t file_size) {
+bool NetworkProducerPeerImpl::CheckIfValidFileSize(size_t file_size) const noexcept {
     return file_size != 0 && file_size <= size_t(1024) * 1024 * 1024 * 2;
 }
 
-bool NetworkProducerPeerImpl::CheckIfValidNetworkOpCode(Opcode opcode) {
+bool NetworkProducerPeerImpl::CheckIfValidNetworkOpCode(Opcode opcode) const noexcept {
     return opcode < kNetOpcodeCount && opcode >= 0;
 }
 
diff --git a/receiver/src/network_producer_peer_impl.h b/receiver/src/network_producer_peer_impl.h
index 722a45a510f821375f1509accd0345bd820c9f02..d7ddf04c03004b18bce6b59924ca2b271a5fc11d 100644
--- a/receiver/src/network_producer_peer_impl.h
+++ b/receiver/src/network_producer_peer_impl.h
@@ -35,8 +35,6 @@ class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
     void InternalPeerReceiverThreadEntryPoint();
     void InternalPeerReceiverDoWork(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err);
     void HandleRawRequestBuffer(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err);
-  protected:
-    void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) override;
   public:
     static const std::vector<RequestHandlerInformation> kRequestHandlers;
     static size_t kRequestHandlerMaxBufferSize;
@@ -53,9 +51,11 @@ class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
     uint32_t GetConnectionId() const override;
     std::string GetAddress() const override;
 
-    FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err);
-    static bool CheckIfValidFileSize(size_t file_size);
-    static bool CheckIfValidNetworkOpCode(Opcode opcode);
+    void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) const noexcept override;
+
+    virtual FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err) const noexcept;
+    virtual bool CheckIfValidFileSize(size_t file_size) const noexcept;
+    virtual bool CheckIfValidNetworkOpCode(Opcode opcode) const noexcept;
 
   public:
     /*
diff --git a/receiver/src/network_producer_peer_impl_functions.cpp b/receiver/src/network_producer_peer_impl_functions.cpp
index 40769824b0a732b1729e9df1ffb03e06f2f529d8..d01f31af6ac5978e1ad36707d6f66524f1de0e24 100644
--- a/receiver/src/network_producer_peer_impl_functions.cpp
+++ b/receiver/src/network_producer_peer_impl_functions.cpp
@@ -1,7 +1,7 @@
 #include "network_producer_peer_impl.h"
 
 namespace hidra2 {
-void NetworkProducerPeerImpl::ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) {
+void NetworkProducerPeerImpl::ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) const noexcept {
     if(!CheckIfValidFileSize(file_size)) {
         *err = ErrorTemplates::kMemoryAllocationError.Generate();
         return;
diff --git a/receiver/src/network_producer_peer_impl_handlers.cpp b/receiver/src/network_producer_peer_impl_handlers.cpp
index 924a95d57cbb127ed769da999c953977a31ca118..6ec5707dfa3f2008954f3a1661d98a1886cbab43 100644
--- a/receiver/src/network_producer_peer_impl_handlers.cpp
+++ b/receiver/src/network_producer_peer_impl_handlers.cpp
@@ -32,10 +32,12 @@ NetworkProducerPeerImpl::StaticInitRequestHandlerList() {
 void NetworkProducerPeerImpl::HandleSendDataRequest(NetworkProducerPeerImpl* self, const SendDataRequest* request,
         SendDataResponse* response) {
     Error err;
+
     self->ReceiveAndSaveFile(request->file_id, request->file_size, &err);
 
     if(!err) {
         response->error_code = NET_ERR__NO_ERROR;
+        return;
     }
 
     if(err == IOErrorTemplates::kFileAlreadyExists) {
diff --git a/receiver/unittests/test_network_producer_peer_impl.cpp b/receiver/unittests/test_network_producer_peer_impl.cpp
index 82ed292f00aa37ebfd24f84f65ae5f6cf350a763..19e3e01387dad5d34cf8ca9c5fb231fc97304ac9 100644
--- a/receiver/unittests/test_network_producer_peer_impl.cpp
+++ b/receiver/unittests/test_network_producer_peer_impl.cpp
@@ -11,6 +11,11 @@ using ::testing::Gt;
 using ::testing::Eq;
 using ::testing::Mock;
 using ::testing::InSequence;
+using ::testing::SetArgPointee;
+using ::hidra2::Error;
+using ::hidra2::ErrorInterface;
+using ::hidra2::FileDescriptor;
+using ::hidra2::SocketDescriptor;
 
 namespace {
 
@@ -21,29 +26,34 @@ TEST(Constructor, CheckGetAddress) {
 }
 
 TEST(CheckIfValidFileSize, ZeroFileSize) {
-    EXPECT_FALSE(hidra2::NetworkProducerPeerImpl::CheckIfValidFileSize(0));
+    hidra2::NetworkProducerPeerImpl networkProducerPeer(0, "");
+    EXPECT_FALSE(networkProducerPeer.CheckIfValidFileSize(0));
 }
 
 TEST(CheckIfValidFileSize, SmallFileSize) {
-    EXPECT_TRUE(hidra2::NetworkProducerPeerImpl::CheckIfValidFileSize(1));
+    hidra2::NetworkProducerPeerImpl networkProducerPeer(0, "");
+    EXPECT_TRUE(networkProducerPeer.CheckIfValidFileSize(1));
 }
 
 TEST(CheckIfValidFileSize, OneGiByteSize) {
-    EXPECT_TRUE(hidra2::NetworkProducerPeerImpl::CheckIfValidFileSize(1024 * 1024 * 1024 * 1));
+    hidra2::NetworkProducerPeerImpl networkProducerPeer(0, "");
+    EXPECT_TRUE(networkProducerPeer.CheckIfValidFileSize(1024 * 1024 * 1024 * 1));
 }
 
 TEST(CheckIfValidFileSize, TwoGiByteSize) {
-    EXPECT_TRUE(hidra2::NetworkProducerPeerImpl::CheckIfValidFileSize(size_t(1024) * 1024 * 1024 * 2));
+    hidra2::NetworkProducerPeerImpl networkProducerPeer(0, "");
+    EXPECT_TRUE(networkProducerPeer.CheckIfValidFileSize(size_t(1024) * 1024 * 1024 * 2));
 }
 
 TEST(CheckIfValidFileSize, MoreThenTwoGiByteSize) {
-    EXPECT_FALSE(hidra2::NetworkProducerPeerImpl::CheckIfValidFileSize(size_t(1024) * 1024 * 1024 * 2 + 1));
+    hidra2::NetworkProducerPeerImpl networkProducerPeer(0, "");
+    EXPECT_FALSE(networkProducerPeer.CheckIfValidFileSize(size_t(1024) * 1024 * 1024 * 2 + 1));
 }
 
 TEST(CreateAndOpenFileByFileId, FolderUnknownIOError) {
     hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
     hidra2::MockIO mockIO;
-    NetworkProducerPeerImpl.__set_io(&mockIO);
+    NetworkProducerPeerImpl.SetIO__(&mockIO);
 
     uint64_t expected_file_id = 5435452453867;
 
@@ -60,7 +70,7 @@ TEST(CreateAndOpenFileByFileId, FolderUnknownIOError) {
 TEST(CreateAndOpenFileByFileId, FolderAlreadyExsistsButFileAlreadyExists) {
     hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
     hidra2::MockIO mockIO;
-    NetworkProducerPeerImpl.__set_io(&mockIO);
+    NetworkProducerPeerImpl.SetIO__(&mockIO);
 
     uint64_t expected_file_id = 543545;
     uint64_t expected_fd = 23432;
@@ -92,7 +102,7 @@ TEST(CreateAndOpenFileByFileId, FolderAlreadyExsistsButFileAlreadyExists) {
 TEST(CreateAndOpenFileByFileId, FolderCreatedButFileAlreadyExists) {
     hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
     hidra2::MockIO mockIO;
-    NetworkProducerPeerImpl.__set_io(&mockIO);
+    NetworkProducerPeerImpl.SetIO__(&mockIO);
 
     uint64_t expected_file_id = 543545;
 
@@ -123,7 +133,7 @@ TEST(CreateAndOpenFileByFileId, FolderCreatedButFileAlreadyExists) {
 TEST(CreateAndOpenFileByFileId, Ok) {
     hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
     hidra2::MockIO mockIO;
-    NetworkProducerPeerImpl.__set_io(&mockIO);
+    NetworkProducerPeerImpl.SetIO__(&mockIO);
 
     uint64_t expected_file_id = 543545;
     uint64_t expected_fd = 23432;
@@ -153,35 +163,256 @@ TEST(CreateAndOpenFileByFileId, Ok) {
 }
 
 TEST(CheckIfValidNetworkOpCode, NormalOpcodeSendData) {
-    EXPECT_TRUE(hidra2::NetworkProducerPeerImpl::CheckIfValidNetworkOpCode(hidra2::Opcode::kNetOpcodeSendData));
+    hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
+    EXPECT_TRUE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode(hidra2::Opcode::kNetOpcodeSendData));
 }
 
 TEST(CheckIfValidNetworkOpCode, FalseOpcode) {
-    EXPECT_FALSE(hidra2::NetworkProducerPeerImpl::CheckIfValidNetworkOpCode(hidra2::Opcode::kNetOpcodeCount));
+    hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
+    EXPECT_FALSE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode(hidra2::Opcode::kNetOpcodeCount));
 }
 
 TEST(CheckIfValidNetworkOpCode, FalseOpcodeByNumber) {
-    EXPECT_FALSE(hidra2::NetworkProducerPeerImpl::CheckIfValidNetworkOpCode((hidra2::Opcode)90));
+    hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
+    EXPECT_FALSE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode((hidra2::Opcode)90));
 }
 
 TEST(CheckIfValidNetworkOpCode, FalseOpcodeByNegativNumber) {
-    //Technically -1 is some bit positive number since Opcode is an unsigned 8 bit number
-    EXPECT_FALSE(hidra2::NetworkProducerPeerImpl::CheckIfValidNetworkOpCode((hidra2::Opcode) - 1));
+    hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
+    //Technically -1 is some big positive number since Opcode is an unsigned 8 bit number
+    EXPECT_FALSE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode((hidra2::Opcode) - 1));
+}
+
+class ReceiveAndSaveFileMock : public hidra2::NetworkProducerPeerImpl {
+ public:
+    ReceiveAndSaveFileMock(hidra2::SocketDescriptor socket_fd, const std::string &address) : NetworkProducerPeerImpl(
+        socket_fd,
+        address) {}
+
+    FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err) const noexcept override {
+        ErrorInterface* error = nullptr;
+        auto data = CreateAndOpenFileByFileId_t(file_id, &error);
+        err->reset(error);
+        return data;
+    }
+    MOCK_CONST_METHOD2(CreateAndOpenFileByFileId_t, FileDescriptor(uint64_t file_id, ErrorInterface** err));
+
+
+    bool CheckIfValidFileSize(size_t file_size) const noexcept override {
+        return CheckIfValidFileSize_t(file_size);
+    }
+    MOCK_CONST_METHOD1(CheckIfValidFileSize_t, bool(size_t file_size));
+
+};
+
+class ReceiveAndSaveFileFixture : public testing::Test {
+  public:
+    const hidra2::SocketDescriptor  expected_socket_descriptor = 20;
+    const std::string               expected_address = "somehost:13579";
+    const uint64_t                  expected_file_id = 314322;
+    const uint64_t                  expected_file_size = 784387;
+    const FileDescriptor            expected_fd = 12643;
+
+    Error err;
+
+    hidra2::MockIO mockIO;
+    std::unique_ptr<ReceiveAndSaveFileMock> networkProducerPeer;
+
+    void SetUp() override {
+        networkProducerPeer.reset(new ReceiveAndSaveFileMock(expected_socket_descriptor, expected_address));
+        networkProducerPeer->SetIO__(&mockIO);
+    }
+};
+
+TEST_F(ReceiveAndSaveFileFixture, CheckFileSizeError) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(false)
+        );
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(hidra2::ErrorTemplates::kMemoryAllocationError));
+}
+
+TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenFileAlreadyExists) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(true)
+        );
+
+    EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+            Return(expected_fd))
+        );
+
+    EXPECT_CALL(mockIO, Skip_t(_, _, _));
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kFileAlreadyExists));
+}
+
+TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileOpenFile) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(true)
+        );
+
+    EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+            Return(expected_fd))
+        );
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
+}
+
+TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileReceivingData) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(true)
+        );
+
+    EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(nullptr),
+            Return(expected_fd)
+        ));
+
+    EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+            Return(-1)
+        ));
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
+}
+
+TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileSavingData) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(true)
+        );
+
+    EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(nullptr),
+            Return(expected_fd)
+        ));
+
+    EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(nullptr),
+            Return(expected_file_size)
+        ));
+
+    EXPECT_CALL(mockIO, Write_t(expected_fd, _, expected_file_size, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+            Return(expected_file_size)
+        ));
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
+}
+
+TEST_F(ReceiveAndSaveFileFixture, Ok) {
+    EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
+        .WillOnce(
+            Return(true)
+        );
+
+    EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
+        .WillOnce(DoAll(
+            SetArgPointee<1>(nullptr),
+            Return(expected_fd)
+        ));
+
+    EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(nullptr),
+            Return(expected_file_size)
+        ));
+
+    EXPECT_CALL(mockIO, Write_t(expected_fd, _, expected_file_size, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(nullptr),
+            Return(expected_file_size)
+        ));
+
+    networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
+
+    ASSERT_THAT(err, Eq(nullptr));
 }
 
-/*
- *
-class ConstructorAndGetterFixture : public testing::Test {
+class HandleSendDataRequestMock : public ReceiveAndSaveFileMock {
+ public:
+    HandleSendDataRequestMock(SocketDescriptor socket_fd, const std::string &address)
+        : ReceiveAndSaveFileMock(socket_fd, address) {}
+
+    void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) const noexcept override {
+        ErrorInterface* error = nullptr;
+        ReceiveAndSaveFile_t(file_id, file_size, &error);
+        err->reset(error);
+    }
+    MOCK_CONST_METHOD3(ReceiveAndSaveFile_t, void(uint64_t file_id, size_t file_size, ErrorInterface** err));
+};
+
+class HandleSendDataRequestFixture : public ReceiveAndSaveFileFixture {
  public:
+    std::unique_ptr<HandleSendDataRequestMock> networkProducerPeer;
+
+    hidra2::SendDataRequest request{};
+    hidra2::SendDataResponse response{};
+
+    void SetUp() override {
+        request.file_id = expected_file_id;
+        request.file_size = expected_file_size;
+
 
-    const std::unique_ptr<hidra2::NetworkProducerPeerImpl> networkProducerPeer;
-    virtual void SetUp() {
-        networkProducerPeer.reset(new hidra2::NetworkProducerPeerImpl(expected_socket_descriptor, expected_address));
+        networkProducerPeer.reset(new HandleSendDataRequestMock(expected_socket_descriptor, expected_address));
+        networkProducerPeer->SetIO__(&mockIO);
     }
 };
 
- */
+TEST_F(HandleSendDataRequestFixture, Ok) {
+    EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
+        .WillOnce(
+            SetArgPointee<2>(nullptr)
+        );
 
+    networkProducerPeer->HandleSendDataRequest(networkProducerPeer.get(), &request, &response);
 
+    ASSERT_THAT(response.error_code, Eq(hidra2::NET_ERR__NO_ERROR));
+}
+
+TEST_F(HandleSendDataRequestFixture, CheckErrorCodeWhenFileIdIsAlreadyUsed) {
+    EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
+        .WillOnce(
+            SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
+        );
+
+    networkProducerPeer->HandleSendDataRequest(networkProducerPeer.get(), &request, &response);
+
+    ASSERT_THAT(response.error_code, Eq(hidra2::NET_ERR__FILEID_ALREADY_IN_USE));
+}
+
+TEST_F(HandleSendDataRequestFixture, CheckErrorCodeWhenUnexpectedError) {
+    EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
+        .WillOnce(
+            SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
+        );
+
+    networkProducerPeer->HandleSendDataRequest(networkProducerPeer.get(), &request, &response);
+
+    ASSERT_THAT(response.error_code, Eq(hidra2::NET_ERR__INTERNAL_SERVER_ERROR));
+}
 
 }
diff --git a/receiver/unittests/test_receiver.cpp b/receiver/unittests/test_receiver.cpp
index 7597556ddd0609d74e678efc6201600239a17f57..d2db9b3504c4ae1c68f698ad835388039faf4755 100644
--- a/receiver/unittests/test_receiver.cpp
+++ b/receiver/unittests/test_receiver.cpp
@@ -26,7 +26,7 @@ TEST(a, b) {
 
     hidra2::Receiver receiver;
 
-    receiver.__set_io(&mockIO);
+    receiver.SetIO__(&mockIO);
 
     InSequence sequence;