From 827ddee985b19ded68ed00fecac766e64a8a308e Mon Sep 17 00:00:00 2001
From: Carsten Patzke <carsten.patzke@desy.de>
Date: Wed, 14 Mar 2018 16:11:13 +0100
Subject: [PATCH] Added unittests to NetworkProducerPeerImpl
---
common/cpp/include/system_wrappers/has_io.h | 4 +-
common/cpp/src/system_io/has_io.cpp | 4 +-
producer/api/src/producer_impl.cpp | 2 +-
producer/api/unittests/test_producer_impl.cpp | 24 +-
receiver/src/network_producer_peer.h | 4 +-
receiver/src/network_producer_peer_impl.cpp | 6 +-
receiver/src/network_producer_peer_impl.h | 10 +-
.../network_producer_peer_impl_functions.cpp | 2 +-
.../network_producer_peer_impl_handlers.cpp | 2 +
.../test_network_producer_peer_impl.cpp | 273 ++++++++++++++++--
receiver/unittests/test_receiver.cpp | 2 +-
11 files changed, 283 insertions(+), 50 deletions(-)
diff --git a/common/cpp/include/system_wrappers/has_io.h b/common/cpp/include/system_wrappers/has_io.h
index ac47213fb..b8005abfd 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 932252941..1fe92e1ed 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 c289e8561..eb932e656 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 1148408cb..9478fbe10 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 2ce505378..e97a269e0 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 9d84e3ccf..9b6c42b24 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 722a45a51..d7ddf04c0 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 40769824b..d01f31af6 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 924a95d57..6ec5707df 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 82ed292f0..19e3e0138 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 7597556dd..d2db9b350 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;
--
GitLab