tcp-lib/tests/tcp_non_blocking.cpp

#include <gtest/gtest.h>

// STL includes
#include <cstring>

// Project includes
#include "tcp_client.hpp"
#include "tcp_server.hpp"


TEST(NonBlockingTcpServer, Accept) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);

    EXPECT_FALSE(server.next_client_available());

    auto conRes = client.connect({"localhost"}, 1234);

    EXPECT_TRUE(server.next_client_available());

    auto accRes = server.accept_next_client();

    EXPECT_FALSE(server.next_client_available());
}

TEST(NonBlockingTcpServer, RestartListening) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);

    auto conRes = client.connect({"localhost"}, 1234);

    EXPECT_TRUE(server.next_client_available());

    auto lisRes2 = server.start_listening(2345);

    EXPECT_FALSE(server.next_client_available());

    auto conRes2 = client.connect({"localhost"}, 2345);

    EXPECT_TRUE(server.next_client_available());

    auto statRes2 = client.get_last_connection_status();
    if (!statRes2) return;
    EXPECT_EQ(statRes2.value(), EISCONN);
}

TEST(NonBlockingTcpServer, StopListening) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);

    auto conRes = client.connect({"localhost"}, 1234);

    EXPECT_TRUE(server.next_client_available());

    server.stop_listening();

    EXPECT_FALSE(server.next_client_available());

    auto conRes2 = client.connect({"localhost"}, 1234);

    EXPECT_EQ(client.get_last_connection_status().value(), ECONNREFUSED);
}

TEST(NonBlockingTcpServer, DataAvailable) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    EXPECT_FALSE(server.data_available());

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    EXPECT_FALSE(server.data_available());

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = client.send(std::as_bytes(std::span(txMsg)));
    EXPECT_EQ(sendRes.value(), txMsg.size());
    EXPECT_TRUE(server.data_available());

    std::array<char, 1024> rxBuffer;
    auto recvRes = server.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_FALSE(server.data_available());
}

TEST(NonBlockingTcpServer, GetClientIPAsString) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();
    auto ipRes  = server.get_client_ip_as_string();
    if (!ipRes) return;

    EXPECT_STREQ(ipRes.value().data(), "127.0.0.1");
}

TEST(NonBlockingTcpClient, Connect) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    /// Default connection status, i.e., before attempting connection

    auto statRes1 = client.get_last_connection_status();
    if (!statRes1) return;
    EXPECT_EQ(statRes1.value(), ENOTCONN);

    /// Connection status when connection is not acknowledged

    auto conRes = client.connect({"localhost"}, 1234);

    auto statRes2 = client.get_last_connection_status();
    if (!statRes2) return;
    EXPECT_EQ(statRes2.value(), ECONNREFUSED);

    /// Connection status when connection is acknowledged

    auto lisRes = server.start_listening(1234);

    auto conRes2 = client.connect({"localhost"}, 1234);

    auto statRes3 = client.get_last_connection_status();
    if (!statRes3) return;
    EXPECT_EQ(statRes3.value(), EISCONN);

    /// Connection status changes when reattempting connection

    auto conRes3 = client.connect({"localhost"}, 12345);

    auto statRes4 = client.get_last_connection_status();
    if (!statRes4) return;
    EXPECT_EQ(statRes4.value(), ECONNREFUSED);
}

TEST(NonBlockingTcpClient, Reconnect) {
    tcp::NonBlockingServer server1;
    tcp::NonBlockingServer server2;
    tcp::NonBlockingClient client;

    auto lisRes1 = server1.start_listening(1234);
    auto lisRes2 = server2.start_listening(2345);

    auto conRes1 = client.connect({"localhost"}, 1234);

    auto statRes1 = client.get_last_connection_status();
    if (!statRes1) return;
    EXPECT_EQ(statRes1.value(), EISCONN);

    auto conRes2 = client.connect({"localhost"}, 2345);

    auto statRes2 = client.get_last_connection_status();
    if (!statRes2) return;
    EXPECT_EQ(statRes2.value(), EISCONN);
}

TEST(NonBlockingTcpClient, DataAvailable) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    EXPECT_FALSE(client.data_available());

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    EXPECT_EQ(client.get_last_connection_status().value(), EISCONN);
    EXPECT_FALSE(client.data_available());

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = server.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());
    EXPECT_TRUE(client.data_available());

    std::array<char, 1024> rxBuffer;
    auto recvRes = client.recv(std::as_writable_bytes(std::span(rxBuffer)));
    EXPECT_EQ(recvRes.value(), txMsg.size());

    EXPECT_FALSE(client.data_available());
}

TEST(NonBlockingTcpClientServer, ClientSendServerReceive) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = client.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = server.recv(std::as_writable_bytes(std::span(rxBuffer)));

    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}

TEST(NonBlockingTcpClientServer, ClientReceiveServerSend) {
    tcp::NonBlockingServer server;
    tcp::NonBlockingClient client;

    auto lisRes = server.start_listening(1234);
    auto conRes = client.connect({"localhost"}, 1234);
    auto accRes = server.accept_next_client();

    std::array<char, 14> txMsg   = {"Hello, World!"};
    auto                 sendRes = server.send(std::as_bytes(std::span(txMsg)));

    EXPECT_EQ(sendRes.value(), txMsg.size());

    std::array<char, 1024> rxBuffer;
    auto recvRes = client.recv(std::as_writable_bytes(std::span(rxBuffer)));

    EXPECT_EQ(recvRes.value(), txMsg.size());
    EXPECT_EQ(std::strcmp(txMsg.data(), rxBuffer.data()), 0);
}