Cynara socket tests

Change-Id: I6615bf57b4a0a8bde39c14a7f82d21b000c52286

diff --git a/unit-tests/test_socket-manager.cpp b/unit-tests/test_socket-manager.cpp
index f869595..60bb0d2 100644 (file)
--- a/unit-tests/test_socket-manager.cpp
+++ b/unit-tests/test_socket-manager.cpp
@@ -28,6 +28,8 @@
 #include <string>
 #include <sstream>
 #include <vector>
+#include <algorithm>
+#include <type_traits>
 
 #include <boost/test/test_tools.hpp>
 #include <boost_macros_wrapper.h>
@@ -53,7 +55,7 @@ constexpr char SERVICE_SOCKET_TEST[] = "/tmp/.central-key-manager-test.sock";
 constexpr CKM::InterfaceID SOCKET_ID_TEST = 42;
 constexpr std::chrono::seconds CV_TIMEOUT(10);
 
-struct TestSocketManager final : public SocketManager {
+struct TestSocketManager : public SocketManager {
        size_t TimeoutQueueSize() const { return m_timeoutQueue.size(); }
 };
 
@@ -166,6 +168,18 @@ void unlinkIfExists(const char* path) {
        BOOST_REQUIRE(ret == 0 || (ret == -1 && err == ENOENT));
 }
 
+enum class SockState {
+       CLOSED = 0,
+       RD = 1,
+       WR = 2,
+       RW = RD | WR,
+};
+
+SockState operator & (SockState lhs, SockState rhs) {
+       using T = std::underlying_type_t <SockState>;
+       return static_cast<SockState>(static_cast<T>(lhs) & static_cast<T>(rhs));
+}
+
 } // namespace
 
 BOOST_AUTO_TEST_SUITE(SOCKET_MANAGER_TEST)
@@ -454,4 +468,167 @@ POSITIVE_TEST_CASE(StressTestRandomSocketEvents)
        }
 }
 
+NEGATIVE_TEST_CASE(CynaraSocket)
+{
+       struct TestSocketManagerExt : public TestSocketManager {
+               void CreateSocket(int sock) {
+                       SocketManager::CreateDefaultReadSocketDescription(sock, false);
+               }
+
+               void CloseSocket(int sock) { SocketManager::CloseSocket(sock); }
+
+               int OutOfRangeSocket() const { return static_cast<int>(m_socketDescriptionVector.size()); }
+
+               size_t OpenedSockets() const {
+                       return std::count_if(m_socketDescriptionVector.begin(),
+                                            m_socketDescriptionVector.end(),
+                                            [](const SocketDescription& desc) { return desc.isOpen(); });
+               }
+
+               void RequireOpened(size_t opened) const {
+                       BOOST_REQUIRE(opened == OpenedSockets());
+
+                       BOOST_REQUIRE(m_timeoutQueue.empty());
+               }
+
+               void RequireCynara(int cynaraSocket) const {
+                       BOOST_REQUIRE(m_cynaraSocket == cynaraSocket);
+               }
+
+               void RequireSocket(int fd, SockState state) const {
+                       BOOST_REQUIRE(fd < OutOfRangeSocket());
+
+                       BOOST_REQUIRE(((state & SockState::RD) == SockState::RD) == FD_ISSET(fd, &m_readSet));
+                       BOOST_REQUIRE(((state & SockState::WR) == SockState::WR) == FD_ISSET(fd, &m_writeSet));
+                       BOOST_REQUIRE((state == SockState::CLOSED) == !m_socketDescriptionVector[fd].isOpen());
+               }
+       };
+
+       constexpr int INVALID_FD = -1;
+
+       TestSocketManagerExt manager;
+       const size_t START_SOCKETS = manager.OpenedSockets();
+       const int OTHER_SOCKET = manager.OutOfRangeSocket();
+       const int CYNARA_SOCKET = OTHER_SOCKET + 1;
+       const int CLOSED_SOCKET = OTHER_SOCKET + 2;
+       const int NEW_CYNARA_SOCKET = OTHER_SOCKET + 3;
+
+       manager.RequireOpened(START_SOCKETS);
+       manager.RequireCynara(INVALID_FD);
+
+       // new descriptor
+       manager.CreateSocket(OTHER_SOCKET);
+       manager.RequireOpened(START_SOCKETS + 1);
+       manager.RequireSocket(OTHER_SOCKET, SockState::RD);
+       manager.RequireCynara(INVALID_FD);
+
+       // new cynara socket
+       manager.CynaraSocket(INVALID_FD, CYNARA_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+
+       // invalid descriptors
+       manager.CynaraSocket(INVALID_FD, INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+
+       // close not opened
+       manager.CynaraSocket(CLOSED_SOCKET, INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+       manager.RequireSocket(CLOSED_SOCKET, SockState::CLOSED);
+
+       // close not cynara
+       manager.CynaraSocket(OTHER_SOCKET, INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+       manager.RequireSocket(OTHER_SOCKET, SockState::RD);
+
+       // close out of bounds
+       manager.CynaraSocket(manager.OutOfRangeSocket(), INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+
+       // open already opened
+       manager.CynaraSocket(INVALID_FD, OTHER_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+       manager.RequireSocket(OTHER_SOCKET, SockState::RD);
+
+       // open already opened for cynara
+       manager.CynaraSocket(INVALID_FD, CYNARA_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(CYNARA_SOCKET);
+
+       // close old & open new cynara socket in WR mode
+       manager.CynaraSocket(CYNARA_SOCKET, NEW_CYNARA_SOCKET, true);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RW);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::CLOSED);
+
+       // do it again
+       manager.CynaraSocket(CYNARA_SOCKET, NEW_CYNARA_SOCKET, true);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RW);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::CLOSED);
+
+       // change to RO
+       manager.CynaraSocket(NEW_CYNARA_SOCKET, NEW_CYNARA_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+
+       // again (no changes)
+       manager.CynaraSocket(NEW_CYNARA_SOCKET, NEW_CYNARA_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+
+       // close other socket manually
+       manager.CloseSocket(OTHER_SOCKET);
+       manager.RequireOpened(START_SOCKETS + 1);
+       manager.RequireSocket(OTHER_SOCKET, SockState::CLOSED);
+
+       // reopen other socket
+       manager.CreateSocket(OTHER_SOCKET);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+       manager.RequireSocket(OTHER_SOCKET, SockState::RD);
+
+       // close old closed cynara socket
+       manager.CynaraSocket(CYNARA_SOCKET, INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::CLOSED);
+
+       // open second cynara socket
+       manager.CynaraSocket(INVALID_FD, CYNARA_SOCKET, false);
+       manager.RequireOpened(START_SOCKETS + 2);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::RD);
+       manager.RequireCynara(NEW_CYNARA_SOCKET);
+       manager.RequireSocket(CYNARA_SOCKET, SockState::CLOSED);
+
+       // close new cynara socket
+       manager.CynaraSocket(NEW_CYNARA_SOCKET, INVALID_FD, false);
+       manager.RequireOpened(START_SOCKETS + 1);
+       manager.RequireSocket(NEW_CYNARA_SOCKET, SockState::CLOSED);
+       manager.RequireCynara(INVALID_FD);
+
+       // close other socket manually
+       manager.CloseSocket(OTHER_SOCKET);
+       manager.RequireOpened(START_SOCKETS);
+       manager.RequireSocket(OTHER_SOCKET, SockState::CLOSED);
+}
+
 BOOST_AUTO_TEST_SUITE_END()