Files
SEQUA-Engine/core/tests/server/test_server.cpp
T
Ange-Marie MAURIN - A2M Systèmes 142e563fcc feat(core): serveur WebSocket du protocole Studio - Core
sequa::core_server : ProtocolSession (poignée de main hello -> welcome/error, JSON provisoire identique à Studio, même règle de compatibilité) séparée du transport CoreServer (IXWebSocket 12.1.0, écoute 127.0.0.1:9100). Exécutable sequa-core. Vérification exclusive du port sous Windows (IXWebSocket active SO_REUSEADDR). Sanitizers appliqués à tout le build (ASan MSVC exige des dépendances instrumentées). ADR 0005. 30 tests (Debug, Release, ASan), dont 4 sur vrais sockets.
2026-11-06 21:23:37 +01:00

184 lines
5.3 KiB
C++

// SPDX-License-Identifier: MPL-2.0
//
// Tests d'intégration : un vrai client WebSocket (IXWebSocket) contre le CoreServer, en
// boucle locale.
#include "sequa/core/server/protocol.hpp"
#include "sequa/core/server/server.hpp"
#include <doctest/doctest.h>
#include <ixwebsocket/IXNetSystem.h>
#include <ixwebsocket/IXWebSocket.h>
#include <nlohmann/json.hpp>
#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
using namespace sequa::core::server;
using nlohmann::json;
namespace {
constexpr auto timeout = std::chrono::seconds(5);
// IXWebSocket ne rapporte pas le port choisi par le système pour le port 0 : on essaie
// une plage de ports locaux jusqu'au premier libre.
std::unique_ptr<CoreServer> start_server()
{
for (int port = 19100; port < 19200; ++port) {
ServerOptions options;
options.port = port;
options.core_version = "9.9.9-test";
auto server = std::make_unique<CoreServer>(options);
if (server->start().empty()) {
return server;
}
}
FAIL("aucun port libre entre 19100 et 19199");
return nullptr;
}
class TestClient {
public:
explicit TestClient(int port)
{
ix::initNetSystem();
socket_.setUrl("ws://127.0.0.1:" + std::to_string(port));
socket_.disableAutomaticReconnection();
socket_.setOnMessageCallback([this](const ix::WebSocketMessagePtr& message) {
const std::lock_guard lock(mutex_);
switch (message->type) {
case ix::WebSocketMessageType::Open:
open_ = true;
break;
case ix::WebSocketMessageType::Message:
messages_.push_back(message->str);
break;
case ix::WebSocketMessageType::Close:
closed_ = true;
close_code_ = message->closeInfo.code;
break;
case ix::WebSocketMessageType::Error:
closed_ = true;
break;
default:
break;
}
changed_.notify_all();
});
socket_.start();
}
~TestClient()
{
socket_.stop();
ix::uninitNetSystem();
}
TestClient(const TestClient&) = delete;
TestClient& operator=(const TestClient&) = delete;
bool wait_open() { return wait([this] { return open_ || closed_; }) && open_; }
void send(const std::string& text) { socket_.sendText(text); }
std::vector<std::string> wait_messages(std::size_t count)
{
wait([this, count] { return messages_.size() >= count || closed_; });
const std::lock_guard lock(mutex_);
return messages_;
}
bool wait_closed() { return wait([this] { return closed_; }); }
std::uint16_t close_code()
{
const std::lock_guard lock(mutex_);
return close_code_;
}
private:
template <typename Predicate>
bool wait(Predicate predicate)
{
std::unique_lock lock(mutex_);
return changed_.wait_for(lock, timeout, predicate);
}
ix::WebSocket socket_;
std::mutex mutex_;
std::condition_variable changed_;
bool open_ = false;
bool closed_ = false;
std::uint16_t close_code_ = 0;
std::vector<std::string> messages_;
};
} // namespace
TEST_CASE("Serveur : poignee de main hello/welcome sur un vrai socket")
{
const auto server = start_server();
REQUIRE(server);
CHECK(server->running());
TestClient client(server->options().port);
REQUIRE(client.wait_open());
client.send(encode_hello(protocol_version, "sequa-studio"));
const auto messages = client.wait_messages(1);
REQUIRE(messages.size() == 1);
const json welcome = json::parse(messages.front());
CHECK(welcome["type"] == "welcome");
CHECK(welcome["payload"]["coreVersion"] == "9.9.9-test");
CHECK(welcome["payload"]["protocolVersion"] == std::string(protocol_version));
}
TEST_CASE("Serveur : version incompatible -> error puis fermeture 1008")
{
const auto server = start_server();
REQUIRE(server);
TestClient client(server->options().port);
REQUIRE(client.wait_open());
client.send(encode_hello("0.2.0", "sequa-studio"));
const auto messages = client.wait_messages(1);
REQUIRE(messages.size() == 1);
CHECK(json::parse(messages.front())["payload"]["code"] == "incompatible-protocol");
REQUIRE(client.wait_closed());
CHECK(client.close_code() == close_code::policy_violation);
}
TEST_CASE("Serveur : plusieurs clients independants")
{
const auto server = start_server();
REQUIRE(server);
TestClient good(server->options().port);
TestClient bad(server->options().port);
REQUIRE(good.wait_open());
REQUIRE(bad.wait_open());
bad.send("pas du json");
good.send(encode_hello(protocol_version, "sequa-studio"));
REQUIRE(bad.wait_closed());
const auto messages = good.wait_messages(1);
REQUIRE(messages.size() == 1);
CHECK(json::parse(messages.front())["type"] == "welcome");
}
TEST_CASE("Serveur : port deja occupe -> start() renvoie une erreur")
{
const auto first = start_server();
REQUIRE(first);
ServerOptions options;
options.port = first->options().port;
CoreServer second(options);
CHECK_FALSE(second.start().empty());
CHECK_FALSE(second.running());
}